mono/arch/x86/x86-codegen.h

   1 /* Copyright (C)  2000 Intel Corporation.  All rights reserved.
   2    Copyright (C)  2001 Ximian, Inc.
   3 //
   4 // $Header: /home/miguel/third-conversion/public/mono/mono/arch/x86/x86-codegen.h,v 1.17 2001/11/27 10:30:39 lupus Exp $
   5 */
   6
   7 #ifndef X86_H
   8 #define X86_H
   9 #include <assert.h>
  10 /*
  11 // x86 register numbers
  12 */
  13 typedef enum {
  14         X86_EAX = 0,
  15         X86_ECX = 1,
  16         X86_EDX = 2,
  17         X86_EBX = 3,
  18         X86_ESP = 4,
  19         X86_EBP = 5,
  20         X86_ESI = 6,
  21         X86_EDI = 7,
  22         X86_NREG
  23 } X86_Reg_No;
  24 /*
  25 // opcodes for alu instructions
  26 */
  27 typedef enum {
  28         X86_ADD = 0,
  29         X86_OR  = 1,
  30         X86_ADC = 2,
  31         X86_SBB = 3,
  32         X86_AND = 4,
  33         X86_SUB = 5,
  34         X86_XOR = 6,
  35         X86_CMP = 7,
  36         X86_NALU
  37 } X86_ALU_Opcode;
  38 /*
  39 // opcodes for shift instructions
  40 */
  41 typedef enum {
  42         X86_SHLD,
  43         X86_SHLR,
  44         X86_SHL = 4,
  45         X86_SHR = 5,
  46         X86_SAR = 7,
  47         X86_NSHIFT = 8
  48 } X86_Shift_Opcode;
  49 /*
  50 // opcodes for floating-point instructions
  51 */
  52 typedef enum {
  53         X86_FADD  = 0,
  54         X86_FMUL  = 1,
  55         X86_FCOM  = 2,
  56         X86_FCOMP = 3,
  57         X86_FSUB  = 4,
  58         X86_FSUBR = 5,
  59         X86_FDIV  = 6,
  60         X86_FDIVR = 7,
  61         X86_NFP   = 8
  62 } X86_FP_Opcode;
  63 /*
  64 // integer conditions codes
  65 */
  66 typedef enum {
  67         X86_CC_EQ = 0,
  68         X86_CC_NE,
  69         X86_CC_LT,
  70         X86_CC_LE,
  71         X86_CC_GT,
  72         X86_CC_GE,
  73         X86_CC_LZ,
  74         X86_CC_GEZ,
  75         X86_CC_P,
  76         X86_CC_NP,
  77         X86_NCC
  78 } X86_CC;
  79 /*
  80 // prefix code
  81 */
  82 typedef enum {
  83         X86_LOCK_PREFIX = 0xF0,
  84         X86_REPNZ_PREFIX = 0xF2,
  85         X86_REPZ_PREFIX = 0xF3,
  86         X86_REP_PREFIX = 0xF3,
  87         X86_CS_PREFIX = 0x2E,
  88         X86_SS_PREFIX = 0x36,
  89         X86_DS_PREFIX = 0x3E,
  90         X86_ES_PREFIX = 0x26,
  91         X86_FS_PREFIX = 0x64,
  92         X86_GS_PREFIX = 0x65,
  93         X86_OPERAND_PREFIX = 0x66,
  94         X86_ADDRESS_PREFIX = 0x67
  95 } X86_Prefix;
  96
  97 static const unsigned char
  98 x86_cc_unsigned_map [X86_NCC] = {
  99         0x74, /* eq  */
 100         0x75, /* ne  */
 101         0x72, /* lt  */
 102         0x76, /* le  */
 103         0x77, /* gt  */
 104         0x73, /* ge  */
 105         0x78, /* lz  */
 106         0x79, /* gez */
 107         0x7a, /* p   */
 108         0x7b, /* np  */
 109 };
 110
 111 static const unsigned char
 112 x86_cc_signed_map [X86_NCC] = {
 113         0x74, /* eq  */
 114         0x75, /* ne  */
 115         0x7c, /* lt  */
 116         0x7e, /* le  */
 117         0x7f, /* gt  */
 118         0x7d, /* ge  */
 119         0x78, /* lz  */
 120         0x79, /* gez */
 121         0x7a, /* p   */
 122         0x7b, /* np  */
 123 };
 124
 125 typedef union {
 126         int val;
 127         unsigned char b [4];
 128 } x86_imm_buf;
 129
 130 #define X86_NOBASEREG (-1)
 131
 132 /*
 133 // bitvector mask for callee-saved registers
 134 */
 135 #define X86_ESI_MASK (1<<X86_ESI)
 136 #define X86_EDI_MASK (1<<X86_EDI)
 137 #define X86_EBX_MASK (1<<X86_EBX)
 138 #define X86_EBP_MASK (1<<X86_EBP)
 139
 140 #define X86_CALLEE_REGS ((1<<X86_EAX) | (1<<X86_ECX) | (1<<X86_EDX))
 141 #define X86_CALLER_REGS ((1<<X86_EBX) | (1<<X86_EBP) | (1<<X86_ESI) | (1<<X86_EDI))
 142 #define X86_BYTE_REGS   ((1<<X86_EAX) | (1<<X86_ECX) | (1<<X86_EDX) | (1<<X86_EBX))
 143
 144 #define X86_IS_SCRATCH(reg) (X86_CALLER_REGS & (1 << (reg))) /* X86_EAX, X86_ECX, or X86_EDX */
 145 #define X86_IS_CALLEE(reg)  (X86_CALLEE_REGS & (1 << (reg)))    /* X86_ESI, X86_EDI, X86_EBX, or X86_EBP */
 146
 147 /*
 148 // Frame structure:
 149 //
 150 //      +--------------------------------+
 151 //      | in_arg[0]       = var[0]           |
 152 //      | in_arg[1]           = var[1]       |
 153 //      |             . . .                              |
 154 //      | in_arg[n_arg-1] = var[n_arg-1] |
 155 //      +--------------------------------+
 156 //      |       return IP                |
 157 //      +--------------------------------+
 158 //      |       saved EBP                | <-- frame pointer (EBP)
 159 //      +--------------------------------+
 160 //      |            ...                 |  n_extra
 161 //      +--------------------------------+
 162 //      |           var[n_arg]               |
 163 //      |           var[n_arg+1]             |  local variables area
 164 //      |          . . .                 |
 165 //      |           var[n_var-1]             |
 166 //      +--------------------------------+
 167 //      |                                            |
 168 //      |                                            |
 169 //      |               spill area               | area for spilling mimic stack
 170 //      |                                            |
 171 //      +--------------------------------|
 172 //      |          ebx                   |
 173 //      |          ebp [ESP_Frame only]  |
 174 //      |              esi                   |  0..3 callee-saved regs
 175 //      |          edi                   | <-- stack pointer (ESP)
 176 //      +--------------------------------+
 177 //      |       stk0                         |
 178 //      |       stk1                         |  operand stack area/
 179 //      |       . . .                        |  out args
 180 //      |       stkn-1                       |
 181 //      +--------------------------------|
 182 //
 183 //
 184 */
 185
 186
 187 /*
 188  * useful building blocks
 189  */
 190 #define x86_address_byte(inst,m,o,r) do { *(inst)++ = ((((m)&0x03)<<6)|(((o)&0x07)<<3)|(((r)&0x07))); } while (0)
 191 #define x86_imm_emit32(inst,imm)     \
 192         do {    \
 193                         x86_imm_buf imb; imb.val = (int) (imm); \
 194                         *(inst)++ = imb.b [0];  \
 195                         *(inst)++ = imb.b [1];  \
 196                         *(inst)++ = imb.b [2];  \
 197                         *(inst)++ = imb.b [3];  \
 198         } while (0)
 199 #define x86_imm_emit16(inst,imm)     do { *(short*)(inst) = (imm); (inst) += 2; } while (0)
 200 #define x86_imm_emit8(inst,imm)      do { *(inst) = (unsigned char)((imm) & 0xff); ++(inst); } while (0)
 201 #define x86_is_imm8(imm)             (((int)(imm) >= -128 && (int)(imm) <= 127))
 202 #define x86_is_imm16(imm)            (((int)(imm) >= -(1<<16) && (int)(imm) <= ((1<<16)-1)))
 203
 204 #define x86_reg_emit(inst,r,regno)   do { x86_address_byte ((inst), 3, (r), (regno)); } while (0)
 205 #define x86_regp_emit(inst,r,regno)  do { x86_address_byte ((inst), 0, (r), (regno)); } while (0)
 206 #define x86_mem_emit(inst,r,disp)    do { x86_address_byte ((inst), 0, (r), 5); x86_imm_emit32((inst), (disp)); } while (0)
 207
 208 #define x86_membase_emit(inst,r,basereg,disp)   do {\
 209         if ((basereg) == X86_ESP) {     \
 210                 if ((disp) == 0) {      \
 211                         x86_address_byte ((inst), 0, (r), X86_ESP);     \
 212                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 213                 } else if (x86_is_imm8((disp))) {       \
 214                         x86_address_byte ((inst), 1, (r), X86_ESP);     \
 215                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 216                         x86_imm_emit8 ((inst), (disp)); \
 217                 } else {        \
 218                         x86_address_byte ((inst), 2, (r), X86_ESP);     \
 219                         x86_address_byte ((inst), 0, X86_ESP, X86_ESP); \
 220                         x86_imm_emit32 ((inst), (disp));        \
 221                 }       \
 222                 break;  \
 223         }       \
 224         if ((disp) == 0 && (basereg) != X86_EBP) {      \
 225                 x86_address_byte ((inst), 0, (r), (basereg));   \
 226                 break;  \
 227         }       \
 228         if (x86_is_imm8((disp))) {      \
 229                 x86_address_byte ((inst), 1, (r), (basereg));   \
 230                 x86_imm_emit8 ((inst), (disp)); \
 231         } else {        \
 232                 x86_address_byte ((inst), 2, (r), (basereg));   \
 233                 x86_imm_emit32 ((inst), (disp));        \
 234         }       \
 235         } while (0)
 236
 237 #define x86_memindex_emit(inst,r,basereg,disp,indexreg,shift)   \
 238         do {    \
 239                 if ((basereg) == X86_NOBASEREG) {       \
 240                         x86_address_byte ((inst), 0, (r), 4);   \
 241                         x86_address_byte ((inst), (shift), (indexreg), 5);      \
 242                         x86_imm_emit32 ((inst), (disp));        \
 243                 } else if ((disp) == 0 && (basereg) != X86_EBP) {       \
 244                         x86_address_byte ((inst), 0, (r), 4);   \
 245                         x86_address_byte ((inst), (shift), (indexreg), (basereg));      \
 246                 } else if (x86_is_imm8((disp))) {       \
 247                         x86_address_byte ((inst), 1, (r), 4);   \
 248                         x86_address_byte ((inst), (shift), (indexreg), (basereg));      \
 249                         x86_imm_emit8 ((inst), (disp)); \
 250                 } else {        \
 251                         x86_address_byte ((inst), 0, (r), 4);   \
 252                         x86_address_byte ((inst), (shift), (indexreg), 5);      \
 253                         x86_imm_emit32 ((inst), (disp));        \
 254                 }       \
 255         } while (0)
 256
 257 #define x86_breakpoint(inst) \
 258         do {    \
 259                 *(inst)++ = 0xcc;       \
 260         } while (0)
 261
 262 #define x86_cld(inst) do { *(inst)++ =(unsigned char)0xfc; } while (0)
 263 #define x86_stosb(inst) do { *(inst)++ =(unsigned char)0xaa; } while (0)
 264 #define x86_stosl(inst) do { *(inst)++ =(unsigned char)0xab; } while (0)
 265
 266 #define x86_prefix(inst,p) do { *(inst)++ =(unsigned char) (p); } while (0)
 267
 268 #define x86_rdtsc(inst) \
 269         do {    \
 270                 *(inst)++ = 0x0f;       \
 271                 *(inst)++ = 0x31;       \
 272         } while (0)
 273
 274 #define x86_cmpxchg_reg_reg(inst,dreg,reg)      \
 275         do {    \
 276                 *(inst)++ = (unsigned char)0x0f;        \
 277                 *(inst)++ = (unsigned char)0xb1;        \
 278                 x86_reg_emit ((inst), (reg), (dreg));   \
 279         } while (0)
 280
 281 #define x86_cmpxchg_mem_reg(inst,mem,reg)       \
 282         do {    \
 283                 *(inst)++ = (unsigned char)0x0f;        \
 284                 *(inst)++ = (unsigned char)0xb1;        \
 285                 x86_mem_emit ((inst), (reg), (mem));    \
 286         } while (0)
 287
 288 #define x86_cmpxchg_membase_reg(inst,basereg,disp,reg)  \
 289         do {    \
 290                 *(inst)++ = (unsigned char)0x0f;        \
 291                 *(inst)++ = (unsigned char)0xb1;        \
 292                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 293         } while (0)
 294
 295 #define x86_xchg_reg_reg(inst,dreg,reg,size)    \
 296         do {    \
 297                 if ((size) == 1)        \
 298                         *(inst)++ = (unsigned char)0x86;        \
 299                 else    \
 300                         *(inst)++ = (unsigned char)0x87;        \
 301                 x86_reg_emit ((inst), (reg), (dreg));   \
 302         } while (0)
 303
 304 #define x86_xchg_mem_reg(inst,mem,reg,size)     \
 305         do {    \
 306                 if ((size) == 1)        \
 307                         *(inst)++ = (unsigned char)0x86;        \
 308                 else    \
 309                         *(inst)++ = (unsigned char)0x87;        \
 310                 x86_mem_emit ((inst), (reg), (mem));    \
 311         } while (0)
 312
 313 #define x86_xchg_membase_reg(inst,basereg,disp,reg,size)        \
 314         do {    \
 315                 if ((size) == 1)        \
 316                         *(inst)++ = (unsigned char)0x86;        \
 317                 else    \
 318                         *(inst)++ = (unsigned char)0x87;        \
 319                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 320         } while (0)
 321
 322 #define x86_inc_mem(inst,mem)   \
 323         do {    \
 324                 *(inst)++ = (unsigned char)0xff;        \
 325                 x86_mem_emit ((inst), 0, (mem));        \
 326         } while (0)
 327
 328 #define x86_inc_membase(inst,basereg,disp)      \
 329         do {    \
 330                 *(inst)++ = (unsigned char)0xff;        \
 331                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
 332         } while (0)
 333
 334 #define x86_inc_reg(inst,reg) do { *(inst)++ = (unsigned char)0x40 + (reg); } while (0)
 335
 336 #define x86_dec_mem(inst,mem)   \
 337         do {    \
 338                 *(inst)++ = (unsigned char)0xff;        \
 339                 x86_mem_emit ((inst), 1, (mem));        \
 340         } while (0)
 341
 342 #define x86_dec_membase(inst,basereg,disp)      \
 343         do {    \
 344                 *(inst)++ = (unsigned char)0xff;        \
 345                 x86_membase_emit ((inst), 1, (basereg), (disp));        \
 346         } while (0)
 347
 348 #define x86_dec_reg(inst,reg) do { *(inst)++ = (unsigned char)0x48 + (reg); } while (0)
 349
 350 #define x86_not_mem(inst,mem)   \
 351         do {    \
 352                 *(inst)++ = (unsigned char)0xf7;        \
 353                 x86_mem_emit ((inst), 2, (mem));        \
 354         } while (0)
 355
 356 #define x86_not_membase(inst,basereg,disp)      \
 357         do {    \
 358                 *(inst)++ = (unsigned char)0xf7;        \
 359                 x86_membase_emit ((inst), 2, (basereg), (disp));        \
 360         } while (0)
 361
 362 #define x86_not_reg(inst,reg)   \
 363         do {    \
 364                 *(inst)++ = (unsigned char)0xf7;        \
 365                 x86_reg_emit ((inst), 2, (reg));        \
 366         } while (0)
 367
 368 #define x86_neg_mem(inst,mem)   \
 369         do {    \
 370                 *(inst)++ = (unsigned char)0xf7;        \
 371                 x86_mem_emit ((inst), 3, (mem));        \
 372         } while (0)
 373
 374 #define x86_neg_membase(inst,basereg,disp)      \
 375         do {    \
 376                 *(inst)++ = (unsigned char)0xf7;        \
 377                 x86_membase_emit ((inst), 3, (basereg), (disp));        \
 378         } while (0)
 379
 380 #define x86_neg_reg(inst,reg)   \
 381         do {    \
 382                 *(inst)++ = (unsigned char)0xf7;        \
 383                 x86_reg_emit ((inst), 3, (reg));        \
 384         } while (0)
 385
 386 #define x86_nop(inst) do { *(inst)++ = (unsigned char)0x90; } while (0)
 387
 388 #define x86_alu_reg_imm(inst,opc,reg,imm)       \
 389         do {    \
 390                 if ((reg) == X86_EAX) { \
 391                         *(inst)++ = (((unsigned char)(opc)) << 3) + 5;  \
 392                         x86_imm_emit32 ((inst), (imm)); \
 393                         break;  \
 394                 }       \
 395                 if (x86_is_imm8((imm))) {       \
 396                         *(inst)++ = (unsigned char)0x83;        \
 397                         x86_reg_emit ((inst), (opc), (reg));    \
 398                         x86_imm_emit8 ((inst), (imm));  \
 399                 } else {        \
 400                         *(inst)++ = (unsigned char)0x81;        \
 401                         x86_reg_emit ((inst), (opc), (reg));    \
 402                         x86_imm_emit32 ((inst), (imm)); \
 403                 }       \
 404         } while (0)
 405
 406 #define x86_alu_mem_imm(inst,opc,mem,imm)       \
 407         do {    \
 408                 if (x86_is_imm8((imm))) {       \
 409                         *(inst)++ = (unsigned char)0x83;        \
 410                         x86_mem_emit ((inst), (opc), (mem));    \
 411                         x86_imm_emit8 ((inst), (imm));  \
 412                 } else {        \
 413                         *(inst)++ = (unsigned char)0x81;        \
 414                         x86_mem_emit ((inst), (opc), (mem));    \
 415                         x86_imm_emit32 ((inst), (imm)); \
 416                 }       \
 417         } while (0)
 418
 419 #define x86_alu_membase_imm(inst,opc,basereg,disp,imm)  \
 420         do {    \
 421                 if (x86_is_imm8((imm))) {       \
 422                         *(inst)++ = (unsigned char)0x83;        \
 423                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 424                         x86_imm_emit8 ((inst), (imm));  \
 425                 } else {        \
 426                         *(inst)++ = (unsigned char)0x81;        \
 427                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 428                         x86_imm_emit32 ((inst), (imm)); \
 429                 }       \
 430         } while (0)
 431
 432 #define x86_alu_mem_reg(inst,opc,mem,reg)       \
 433         do {    \
 434                 *(inst)++ = (((unsigned char)(opc)) << 3) + 1;  \
 435                 x86_mem_emit ((inst), (reg), (mem));    \
 436         } while (0)
 437
 438 #define x86_alu_membase_reg(inst,opc,basereg,disp,reg)  \
 439         do {    \
 440                 *(inst)++ = (((unsigned char)(opc)) << 3) + 1;  \
 441                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 442         } while (0)
 443
 444 #define x86_alu_reg_reg(inst,opc,dreg,reg)      \
 445         do {    \
 446                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 447                 x86_reg_emit ((inst), (dreg), (reg));   \
 448         } while (0)
 449
 450 #define x86_alu_reg_mem(inst,opc,reg,mem)       \
 451         do {    \
 452                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 453                 x86_mem_emit ((inst), (reg), (mem));    \
 454         } while (0)
 455
 456 #define x86_alu_reg_membase(inst,opc,reg,basereg,disp)  \
 457         do {    \
 458                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 459                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 460         } while (0)
 461
 462 #define x86_test_reg_imm(inst,reg,imm)  \
 463         do {    \
 464                 if ((reg) == X86_EAX) { \
 465                         *(inst)++ = (unsigned char)0xa9;        \
 466                 } else {        \
 467                         *(inst)++ = (unsigned char)0xf7;        \
 468                         x86_reg_emit ((inst), 0, (reg));        \
 469                 }       \
 470                 x86_imm_emit32 ((inst), (imm)); \
 471         } while (0)
 472
 473 #define x86_test_mem_imm(inst,mem,imm)  \
 474         do {    \
 475                 *(inst)++ = (unsigned char)0xf7;        \
 476                 x86_mem_emit ((inst), 0, (mem));        \
 477                 x86_imm_emit32 ((inst), (imm)); \
 478         } while (0)
 479
 480 #define x86_test_membase_imm(inst,basereg,disp,imm)     \
 481         do {    \
 482                 *(inst)++ = (unsigned char)0xf7;        \
 483                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
 484                 x86_imm_emit32 ((inst), (imm)); \
 485         } while (0)
 486
 487 #define x86_test_reg_reg(inst,dreg,reg) \
 488         do {    \
 489                 *(inst)++ = (unsigned char)0x85;        \
 490                 x86_reg_emit ((inst), (reg), (dreg));   \
 491         } while (0)
 492
 493 #define x86_test_mem_reg(inst,mem,reg)  \
 494         do {    \
 495                 *(inst)++ = (unsigned char)0x85;        \
 496                 x86_mem_emit ((inst), (reg), (mem));    \
 497         } while (0)
 498
 499 #define x86_test_membase_reg(inst,basereg,disp,reg)     \
 500         do {    \
 501                 *(inst)++ = (unsigned char)0x85;        \
 502                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 503         } while (0)
 504
 505 #define x86_shift_reg_imm(inst,opc,reg,imm)     \
 506         do {    \
 507                 if ((imm) == 1) {       \
 508                         *(inst)++ = (unsigned char)0xd1;        \
 509                         x86_reg_emit ((inst), (opc), (reg));    \
 510                 } else {        \
 511                         *(inst)++ = (unsigned char)0xc1;        \
 512                         x86_reg_emit ((inst), (opc), (reg));    \
 513                         x86_imm_emit8 ((inst), (imm));  \
 514                 }       \
 515         } while (0)
 516
 517 #define x86_shift_mem_imm(inst,opc,mem,imm)     \
 518         do {    \
 519                 if ((imm) == 1) {       \
 520                         *(inst)++ = (unsigned char)0xd1;        \
 521                         x86_mem_emit ((inst), (opc), (mem));    \
 522                 } else {        \
 523                         *(inst)++ = (unsigned char)0xc1;        \
 524                         x86_mem_emit ((inst), (opc), (mem));    \
 525                         x86_imm_emit8 ((inst), (imm));  \
 526                 }       \
 527         } while (0)
 528
 529 #define x86_shift_membase_imm(inst,opc,basereg,disp,imm)        \
 530         do {    \
 531                 if ((imm) == 1) {       \
 532                         *(inst)++ = (unsigned char)0xd1;        \
 533                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 534                 } else {        \
 535                         *(inst)++ = (unsigned char)0xc1;        \
 536                         x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 537                         x86_imm_emit8 ((inst), (imm));  \
 538                 }       \
 539         } while (0)
 540
 541 #define x86_shift_reg(inst,opc,reg)     \
 542         do {    \
 543                 *(inst)++ = (unsigned char)0xd3;        \
 544                 x86_reg_emit ((inst), (opc), (reg));    \
 545         } while (0)
 546
 547 #define x86_shift_mem(inst,opc,mem)     \
 548         do {    \
 549                 *(inst)++ = (unsigned char)0xd3;        \
 550                 x86_mem_emit ((inst), (opc), (mem));    \
 551         } while (0)
 552
 553 #define x86_shift_membase(inst,opc,basereg,disp)        \
 554         do {    \
 555                 *(inst)++ = (unsigned char)0xd3;        \
 556                 x86_membase_emit ((inst), (opc), (basereg), (disp));    \
 557         } while (0)
 558
 559 /*
 560  * Multi op shift missing.
 561  */
 562
 563 /*
 564  * EDX:EAX = EAX * rm
 565  */
 566 #define x86_mul_reg(inst,reg,is_signed) \
 567         do {    \
 568                 *(inst)++ = (unsigned char)0xf7;        \
 569                 x86_reg_emit ((inst), 4 + ((is_signed) ? 1 : 0), (reg));        \
 570         } while (0)
 571
 572 #define x86_mul_mem(inst,mem,is_signed) \
 573         do {    \
 574                 *(inst)++ = (unsigned char)0xf7;        \
 575                 x86_mem_emit ((inst), 4 + ((is_signed) ? 1 : 0), (mem));        \
 576         } while (0)
 577
 578 #define x86_mul_membase(inst,basereg,disp,is_signed)    \
 579         do {    \
 580                 *(inst)++ = (unsigned char)0xf7;        \
 581                 x86_membase_emit ((inst), 4 + ((is_signed) ? 1 : 0), (basereg), (disp));        \
 582         } while (0)
 583
 584 /*
 585  * r *= rm
 586  */
 587 #define x86_imul_reg_reg(inst,dreg,reg) \
 588         do {    \
 589                 *(inst)++ = (unsigned char)0x0f;        \
 590                 *(inst)++ = (unsigned char)0xaf;        \
 591                 x86_reg_emit ((inst), (dreg), (reg));   \
 592         } while (0)
 593
 594 #define x86_imul_reg_mem(inst,reg,mem)  \
 595         do {    \
 596                 *(inst)++ = (unsigned char)0x0f;        \
 597                 *(inst)++ = (unsigned char)0xaf;        \
 598                 x86_mem_emit ((inst), (reg), (mem));    \
 599         } while (0)
 600
 601 #define x86_imul_reg_membase(inst,reg,basereg,disp)     \
 602         do {    \
 603                 *(inst)++ = (unsigned char)0x0f;        \
 604                 *(inst)++ = (unsigned char)0xaf;        \
 605                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 606         } while (0)
 607
 608 /*
 609  * dreg = rm * imm
 610  */
 611 #define x86_imul_reg_reg_imm(inst,dreg,reg,imm) \
 612         do {    \
 613                 if (x86_is_imm8 ((imm))) {      \
 614                         *(inst)++ = (unsigned char)0x6b;        \
 615                         x86_reg_emit ((inst), (dreg), (reg));   \
 616                         x86_imm_emit8 ((inst), (imm));  \
 617                 } else {        \
 618                         *(inst)++ = (unsigned char)0x69;        \
 619                         x86_reg_emit ((inst), (dreg), (reg));   \
 620                         x86_imm_emit32 ((inst), (imm)); \
 621                 }       \
 622         } while (0)
 623
 624 #define x86_imul_reg_mem_imm(inst,reg,mem,imm)  \
 625         do {    \
 626                 if (x86_is_imm8 ((imm))) {      \
 627                         *(inst)++ = (unsigned char)0x6b;        \
 628                         x86_mem_emit ((inst), (reg), (mem));    \
 629                         x86_imm_emit8 ((inst), (imm));  \
 630                 } else {        \
 631                         *(inst)++ = (unsigned char)0x69;        \
 632                         x86_reg_emit ((inst), (reg), (mem));    \
 633                         x86_imm_emit32 ((inst), (imm)); \
 634                 }       \
 635         } while (0)
 636
 637 #define x86_imul_reg_membase_imm(inst,reg,basereg,disp,imm)     \
 638         do {    \
 639                 if (x86_is_imm8 ((imm))) {      \
 640                         *(inst)++ = (unsigned char)0x6b;        \
 641                         x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 642                         x86_imm_emit8 ((inst), (imm));  \
 643                 } else {        \
 644                         *(inst)++ = (unsigned char)0x69;        \
 645                         x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 646                         x86_imm_emit32 ((inst), (imm)); \
 647                 }       \
 648         } while (0)
 649
 650 /*
 651  * divide EDX:EAX by rm;
 652  * eax = quotient, edx = remainder
 653  */
 654
 655 #define x86_div_reg(inst,reg,is_signed) \
 656         do {    \
 657                 *(inst)++ = (unsigned char)0xf7;        \
 658                 x86_reg_emit ((inst), 6 + ((is_signed) ? 1 : 0), (reg));        \
 659         } while (0)
 660
 661 #define x86_div_mem(inst,mem,is_signed) \
 662         do {    \
 663                 *(inst)++ = (unsigned char)0xf7;        \
 664                 x86_mem_emit ((inst), 6 + ((is_signed) ? 1 : 0), (mem));        \
 665         } while (0)
 666
 667 #define x86_div_membase(inst,basereg,disp,is_signed)    \
 668         do {    \
 669                 *(inst)++ = (unsigned char)0xf7;        \
 670                 x86_membase_emit ((inst), 6 + ((is_signed) ? 1 : 0), (basereg), (disp));        \
 671         } while (0)
 672
 673 #define x86_mov_mem_reg(inst,mem,reg,size)      \
 674         do {    \
 675                 switch ((size)) {       \
 676                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 677                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 678                 case 4: *(inst)++ = (unsigned char)0x89; break; \
 679                 default: assert (0);    \
 680                 }       \
 681                 x86_mem_emit ((inst), (reg), (mem));    \
 682         } while (0)
 683
 684 #define x86_mov_regp_reg(inst,regp,reg,size)    \
 685         do {    \
 686                 switch ((size)) {       \
 687                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 688                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 689                 case 4: *(inst)++ = (unsigned char)0x89; break; \
 690                 default: assert (0);    \
 691                 }       \
 692                 x86_regp_emit ((inst), (reg), (regp));  \
 693         } while (0)
 694
 695 #define x86_mov_membase_reg(inst,basereg,disp,reg,size) \
 696         do {    \
 697                 switch ((size)) {       \
 698                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 699                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 700                 case 4: *(inst)++ = (unsigned char)0x89; break; \
 701                 default: assert (0);    \
 702                 }       \
 703                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 704         } while (0)
 705
 706 #define x86_mov_memindex_reg(inst,basereg,disp,indexreg,shift,reg,size) \
 707         do {    \
 708                 switch ((size)) {       \
 709                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 710                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 711                 case 4: *(inst)++ = (unsigned char)0x89; break; \
 712                 default: assert (0);    \
 713                 }       \
 714                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
 715         } while (0)
 716
 717 #define x86_mov_reg_reg(inst,dreg,reg,size)     \
 718         do {    \
 719                 switch ((size)) {       \
 720                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 721                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 722                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
 723                 default: assert (0);    \
 724                 }       \
 725                 x86_reg_emit ((inst), (dreg), (reg));   \
 726         } while (0)
 727
 728 #define x86_mov_reg_mem(inst,reg,mem,size)      \
 729         do {    \
 730                 switch ((size)) {       \
 731                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 732                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 733                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
 734                 default: assert (0);    \
 735                 }       \
 736                 x86_mem_emit ((inst), (reg), (mem));    \
 737         } while (0)
 738
 739 #define x86_mov_reg_membase(inst,reg,basereg,disp,size) \
 740         do {    \
 741                 switch ((size)) {       \
 742                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 743                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 744                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
 745                 default: assert (0);    \
 746                 }       \
 747                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 748         } while (0)
 749
 750 #define x86_mov_reg_memindex(inst,reg,basereg,disp,indexreg,shift,size) \
 751         do {    \
 752                 switch ((size)) {       \
 753                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 754                 case 2: *(inst)++ = (unsigned char)0x66; /* fall through */     \
 755                 case 4: *(inst)++ = (unsigned char)0x8b; break; \
 756                 default: assert (0);    \
 757                 }       \
 758                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
 759         } while (0)
 760
 761 #define x86_mov_reg_imm(inst,reg,imm)   \
 762         do {    \
 763                 if ((imm) == 0) {       \
 764                         x86_alu_reg_reg ((inst), X86_XOR, (reg), (reg));        \
 765                 } else {        \
 766                         *(inst)++ = (unsigned char)0xb8 + (reg);        \
 767                         x86_imm_emit32 ((inst), (imm)); \
 768                 }       \
 769         } while (0)
 770
 771 #define x86_mov_mem_imm(inst,mem,imm,size)      \
 772         do {    \
 773                 if ((size) == 1) {      \
 774                         *(inst)++ = (unsigned char)0xc6;        \
 775                         x86_mem_emit ((inst), 0, (mem));        \
 776                         x86_imm_emit8 ((inst), (imm));  \
 777                 } else if ((size) == 2) {       \
 778                         *(inst)++ = (unsigned char)0x66;        \
 779                         *(inst)++ = (unsigned char)0xc7;        \
 780                         x86_mem_emit ((inst), 0, (mem));        \
 781                         x86_imm_emit16 ((inst), (imm)); \
 782                 } else {        \
 783                         *(inst)++ = (unsigned char)0xc7;        \
 784                         x86_mem_emit ((inst), 0, (mem));        \
 785                         x86_imm_emit32 ((inst), (imm)); \
 786                 }       \
 787         } while (0)
 788
 789 #define x86_mov_membase_imm(inst,basereg,disp,imm,size) \
 790         do {    \
 791                 if ((size) == 1) {      \
 792                         *(inst)++ = (unsigned char)0xc6;        \
 793                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
 794                         x86_imm_emit8 ((inst), (imm));  \
 795                 } else if ((size) == 2) {       \
 796                         *(inst)++ = (unsigned char)0x66;        \
 797                         *(inst)++ = (unsigned char)0xc7;        \
 798                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
 799                         x86_imm_emit16 ((inst), (imm)); \
 800                 } else {        \
 801                         *(inst)++ = (unsigned char)0xc7;        \
 802                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
 803                         x86_imm_emit32 ((inst), (imm)); \
 804                 }       \
 805         } while (0)
 806
 807 #define x86_lea_mem(inst,reg,mem)       \
 808         do {    \
 809                 *(inst)++ = (unsigned char)0x8d;        \
 810                 x86_mem_emit ((inst), (reg), (mem));    \
 811         } while (0)
 812
 813 #define x86_lea_membase(inst,reg,basereg,disp)  \
 814         do {    \
 815                 *(inst)++ = (unsigned char)0x8d;        \
 816                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
 817         } while (0)
 818
 819 #define x86_lea_memindex(inst,reg,basereg,disp,indexreg,shift)  \
 820         do {    \
 821                 *(inst)++ = (unsigned char)0x8d;        \
 822                 x86_memindex_emit ((inst), (reg), (basereg), (disp), (indexreg), (shift));      \
 823         } while (0)
 824
 825 #define x86_widen_reg(inst,dreg,reg,is_signed,is_half)  \
 826         do {    \
 827                 unsigned char op = 0xb6;        \
 828                 *(inst)++ = (unsigned char)0x0f;        \
 829                 if ((is_signed)) op += 0x08;    \
 830                 if ((is_half)) op += 0x01;      \
 831                 *(inst)++ = op; \
 832                 x86_reg_emit ((inst), (dreg), (reg));   \
 833         } while (0)
 834
 835 #define x86_widen_mem(inst,dreg,mem,is_signed,is_half)  \
 836         do {    \
 837                 unsigned char op = 0xb6;        \
 838                 *(inst)++ = (unsigned char)0x0f;        \
 839                 if ((is_signed)) op += 0x08;    \
 840                 if ((is_half)) op += 0x01;      \
 841                 *(inst)++ = op; \
 842                 x86_mem_emit ((inst), (dreg), (mem));   \
 843         } while (0)
 844
 845 #define x86_widen_membase(inst,dreg,basereg,disp,is_signed,is_half)     \
 846         do {    \
 847                 unsigned char op = 0xb6;        \
 848                 *(inst)++ = (unsigned char)0x0f;        \
 849                 if ((is_signed)) op += 0x08;    \
 850                 if ((is_half)) op += 0x01;      \
 851                 *(inst)++ = op; \
 852                 x86_membase_emit ((inst), (dreg), (basereg), (disp));   \
 853         } while (0)
 854
 855 #define x86_widen_memindex(inst,dreg,basereg,disp,indexreg,shift,is_signed,is_half)     \
 856         do {    \
 857                 unsigned char op = 0xb6;        \
 858                 *(inst)++ = (unsigned char)0x0f;        \
 859                 if ((is_signed)) op += 0x08;    \
 860                 if ((is_half)) op += 0x01;      \
 861                 *(inst)++ = op; \
 862                 x86_memindex_emit ((inst), (dreg), (basereg), (disp), (indexreg), (shift));     \
 863         } while (0)
 864
 865 #define x86_cdq(inst)  do { *(inst)++ = (unsigned char)0x99; } while (0)
 866 #define x86_wait(inst) do { *(inst)++ = (unsigned char)0x9b; } while (0)
 867
 868 #define x86_fp_op_mem(inst,opc,mem,is_double)   \
 869         do {    \
 870                 *(inst)++ = (is_double) ? (unsigned char)0xdc : (unsigned char)0xd8;    \
 871                 x86_mem_emit ((inst), (opc), (mem));    \
 872         } while (0)
 873
 874 #define x86_fp_op(inst,opc,index)       \
 875         do {    \
 876                 *(inst)++ = (unsigned char)0xd8;        \
 877                 *(inst)++ = (unsigned char)0xc0+((opc)<<3)+((index)&0x07);      \
 878         } while (0)
 879
 880 #define x86_fp_op_reg(inst,opc,index,pop_stack) \
 881         do {    \
 882                 static const unsigned char map[] = { 0, 1, 2, 3, 5, 4, 7, 6, 8};        \
 883                 *(inst)++ = (pop_stack) ? (unsigned char)0xde : (unsigned char)0xdc;    \
 884                 *(inst)++ = (unsigned char)0xc0+(map[(opc)]<<3)+((index)&0x07); \
 885         } while (0)
 886
 887 #define x86_fstp(inst,index)    \
 888         do {    \
 889                 *(inst)++ = (unsigned char)0xdd;        \
 890                 *(inst)++ = (unsigned char)0xd8+(index);        \
 891         } while (0)
 892
 893 #define x86_fcompp(inst)        \
 894         do {    \
 895                 *(inst)++ = (unsigned char)0xde;        \
 896                 *(inst)++ = (unsigned char)0xd9;        \
 897         } while (0)
 898
 899 #define x86_fnstsw(inst)        \
 900         do {    \
 901                 *(inst)++ = (unsigned char)0xdf;        \
 902                 *(inst)++ = (unsigned char)0xe0;        \
 903         } while (0)
 904
 905 #define x86_fnstcw(inst,mem)    \
 906         do {    \
 907                 *(inst)++ = (unsigned char)0xd9;        \
 908                 x86_mem_emit ((inst), 7, (mem));        \
 909         } while (0)
 910
 911 #define x86_fnstcw_membase(inst,basereg,disp)   \
 912         do {    \
 913                 *(inst)++ = (unsigned char)0xd9;        \
 914                 x86_membase_emit ((inst), 7, (basereg), (disp));        \
 915         } while (0)
 916
 917 #define x86_fldcw(inst,mem)     \
 918         do {    \
 919                 *(inst)++ = (unsigned char)0xd9;        \
 920                 x86_mem_emit ((inst), 5, (mem));        \
 921         } while (0)
 922
 923 #define x86_fldcw_membase(inst,basereg,disp)    \
 924         do {    \
 925                 *(inst)++ = (unsigned char)0xd9;        \
 926                 x86_membase_emit ((inst), 5, (basereg), (disp));        \
 927         } while (0)
 928
 929 #define x86_fchs(inst)  \
 930         do {    \
 931                 *(inst)++ = (unsigned char)0xd9;        \
 932                 *(inst)++ = (unsigned char)0xe0;        \
 933         } while (0)
 934
 935 #define x86_frem(inst)  \
 936         do {    \
 937                 *(inst)++ = (unsigned char)0xd9;        \
 938                 *(inst)++ = (unsigned char)0xf8;        \
 939         } while (0)
 940
 941 #define x86_fxch(inst,index)    \
 942         do {    \
 943                 *(inst)++ = (unsigned char)0xd9;        \
 944                 *(inst)++ = (unsigned char)0xc8 + ((index) & 0x07);     \
 945         } while (0)
 946
 947 #define x86_fcomip(inst,index)  \
 948         do {    \
 949                 *(inst)++ = (unsigned char)0xdf;        \
 950                 *(inst)++ = (unsigned char)0xf0 + ((index) & 0x07);     \
 951         } while (0)
 952
 953 #define x86_fld(inst,mem,is_double)     \
 954         do {    \
 955                 *(inst)++ = (is_double) ? (unsigned char)0xdd : (unsigned char)0xd9;    \
 956                 x86_mem_emit ((inst), 0, (mem));        \
 957         } while (0)
 958
 959 #define x86_fld_membase(inst,basereg,disp,is_double)    \
 960         do {    \
 961                 *(inst)++ = (is_double) ? (unsigned char)0xdd : (unsigned char)0xd9;    \
 962                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
 963         } while (0)
 964
 965 #define x86_fld80(inst,mem)     \
 966         do {    \
 967                 *(inst)++ = (unsigned char)0xdb;        \
 968                 x86_mem_emit ((inst), 5, (mem));        \
 969         } while (0)
 970
 971 #define x86_fld80_membase(inst,basereg,disp)    \
 972         do {    \
 973                 *(inst)++ = (unsigned char)0xdb;        \
 974                 x86_membase_emit ((inst), 5, (basereg), (disp));        \
 975         } while (0)
 976
 977 #define x86_fild(inst,mem,is_long)      \
 978         do {    \
 979                 if ((is_long)) {        \
 980                         *(inst)++ = (unsigned char)0xdf;        \
 981                         x86_mem_emit ((inst), 5, (mem));        \
 982                 } else {        \
 983                         *(inst)++ = (unsigned char)0xdb;        \
 984                         x86_mem_emit ((inst), 0, (mem));        \
 985                 }       \
 986         } while (0)
 987
 988 #define x86_fild_membase(inst,basereg,disp,is_long)     \
 989         do {    \
 990                 if ((is_long)) {        \
 991                         *(inst)++ = (unsigned char)0xdf;        \
 992                         x86_membase_emit ((inst), 5, (basereg), (disp));        \
 993                 } else {        \
 994                         *(inst)++ = (unsigned char)0xdb;        \
 995                         x86_membase_emit ((inst), 0, (basereg), (disp));        \
 996                 }       \
 997         } while (0)
 998
 999 #define x86_fld_reg(inst,index) \
1000         do {    \
1001                 *(inst)++ = (unsigned char)0xd9;        \
1002                 *(inst)++ = (unsigned char)0xc0 + ((index) & 0x07);     \
1003         } while (0)
1004
1005 #define x86_fldz(inst)  \
1006         do {    \
1007                 *(inst)++ = (unsigned char)0xd9;        \
1008                 *(inst)++ = (unsigned char)0xee;        \
1009         } while (0)
1010
1011 #define x86_fld1(inst)  \
1012         do {    \
1013                 *(inst)++ = (unsigned char)0xd9;        \
1014                 *(inst)++ = (unsigned char)0xe8;        \
1015         } while (0)
1016
1017 #define x86_fst(inst,mem,is_double,pop_stack)   \
1018         do {    \
1019                 *(inst)++ = (is_double) ? (unsigned char)0xdd: (unsigned char)0xd9;     \
1020                 x86_mem_emit ((inst), 2 + ((pop_stack) ? 1 : 0), (mem));        \
1021         } while (0)
1022
1023 #define x86_fst_membase(inst,basereg,disp,is_double,pop_stack)  \
1024         do {    \
1025                 *(inst)++ = (is_double) ? (unsigned char)0xdd: (unsigned char)0xd9;     \
1026                 x86_membase_emit ((inst), 2 + ((pop_stack) ? 1 : 0), (basereg), (disp));        \
1027         } while (0)
1028
1029 #define x86_fist_pop(inst,mem,is_long)  \
1030         do {    \
1031                 if ((is_long)) {        \
1032                         *(inst)++ = (unsigned char)0xdf;        \
1033                         x86_mem_emit ((inst), 7, (mem));        \
1034                 } else {        \
1035                         *(inst)++ = (unsigned char)0xdb;        \
1036                         x86_mem_emit ((inst), 3, (mem));        \
1037                 }       \
1038         } while (0)
1039
1040 #define x86_fist_pop_membase(inst,basereg,disp,is_long) \
1041         do {    \
1042                 if ((is_long)) {        \
1043                         *(inst)++ = (unsigned char)0xdf;        \
1044                         x86_membase_emit ((inst), 7, (basereg), (disp));        \
1045                 } else {        \
1046                         *(inst)++ = (unsigned char)0xdb;        \
1047                         x86_membase_emit ((inst), 3, (basereg), (disp));        \
1048                 }       \
1049         } while (0)
1050
1051 #define x86_push_reg(inst,reg)  \
1052         do {    \
1053                 *(inst)++ = (unsigned char)0x50 + (reg);        \
1054         } while (0)
1055
1056 #define x86_push_regp(inst,reg) \
1057         do {    \
1058                 *(inst)++ = (unsigned char)0xff;        \
1059                 x86_regp_emit ((inst), 6, (reg));       \
1060         } while (0)
1061
1062 #define x86_push_mem(inst,mem)  \
1063         do {    \
1064                 *(inst)++ = (unsigned char)0xff;        \
1065                 x86_mem_emit ((inst), 6, (mem));        \
1066         } while (0)
1067
1068 #define x86_push_membase(inst,basereg,disp)     \
1069         do {    \
1070                 *(inst)++ = (unsigned char)0xff;        \
1071                 x86_membase_emit ((inst), 6, (basereg), (disp));        \
1072         } while (0)
1073
1074 #define x86_push_imm(inst,imm)  \
1075         do {    \
1076                 *(inst)++ = (unsigned char)0x68;        \
1077                 x86_imm_emit32 ((inst), (imm)); \
1078         } while (0)
1079
1080 #define x86_pop_reg(inst,reg)   \
1081         do {    \
1082                 *(inst)++ = (unsigned char)0x58 + (reg);        \
1083         } while (0)
1084
1085 #define x86_pop_mem(inst,mem)   \
1086         do {    \
1087                 *(inst)++ = (unsigned char)0x87;        \
1088                 x86_mem_emit ((inst), 0, (mem));        \
1089         } while (0)
1090
1091 #define x86_pop_membase(inst,basereg,disp)      \
1092         do {    \
1093                 *(inst)++ = (unsigned char)0x87;        \
1094                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
1095         } while (0)
1096
1097 #define x86_pushad(inst) do { *(inst)++ = (unsigned char)0x60; } while (0)
1098 #define x86_pushfd(inst) do { *(inst)++ = (unsigned char)0x9c; } while (0)
1099 #define x86_popad(inst)  do { *(inst)++ = (unsigned char)0x61; } while (0)
1100 #define x86_popfd(inst)  do { *(inst)++ = (unsigned char)0x9d; } while (0)
1101
1102 #define x86_jump32(inst,imm)    \
1103         do {    \
1104                 *(inst)++ = (unsigned char)0xe9;        \
1105                 x86_imm_emit32 ((inst), (imm)); \
1106         } while (0)
1107
1108 #define x86_jump8(inst,imm)     \
1109         do {    \
1110                 *(inst)++ = (unsigned char)0xeb;        \
1111                 x86_imm_emit8 ((inst), (imm));  \
1112         } while (0)
1113
1114 #define x86_jump_reg(inst,reg)  \
1115         do {    \
1116                 *(inst)++ = (unsigned char)0xff;        \
1117                 x86_reg_emit ((inst), 4, (reg));        \
1118         } while (0)
1119
1120 #define x86_jump_mem(inst,mem)  \
1121         do {    \
1122                 *(inst)++ = (unsigned char)0xff;        \
1123                 x86_mem_emit ((inst), 4, (mem));        \
1124         } while (0)
1125
1126 #define x86_jump_membase(inst,basereg,disp)     \
1127         do {    \
1128                 *(inst)++ = (unsigned char)0xff;        \
1129                 x86_membase_emit ((inst), 4, (basereg), (disp));        \
1130         } while (0)
1131
1132 /*
1133  * target is a pointer in our buffer.
1134  */
1135 #define x86_jump_code(inst,target)      \
1136         do {    \
1137                 int t = (unsigned char*)(target) - (inst) - 2;  \
1138                 if (x86_is_imm8(t)) {   \
1139                         x86_jump8 ((inst), t);  \
1140                 } else {        \
1141                         t -= 3; \
1142                         x86_jump32 ((inst), t); \
1143                 }       \
1144         } while (0)
1145
1146 #define x86_jump_disp(inst,disp)        \
1147         do {    \
1148                 int t = (disp) - 2;     \
1149                 if (x86_is_imm8(t)) {   \
1150                         x86_jump8 ((inst), t);  \
1151                 } else {        \
1152                         t -= 3; \
1153                         x86_jump32 ((inst), t); \
1154                 }       \
1155         } while (0)
1156
1157 #define x86_branch8(inst,cond,imm,is_signed)    \
1158         do {    \
1159                 if ((is_signed))        \
1160                         *(inst)++ = x86_cc_signed_map [(cond)]; \
1161                 else    \
1162                         *(inst)++ = x86_cc_unsigned_map [(cond)];       \
1163                 x86_imm_emit8 ((inst), (imm));  \
1164         } while (0)
1165
1166 #define x86_branch32(inst,cond,imm,is_signed)   \
1167         do {    \
1168                 *(inst)++ = (unsigned char)0x0f;        \
1169                 if ((is_signed))        \
1170                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x10;  \
1171                 else    \
1172                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x10;        \
1173                 x86_imm_emit32 ((inst), (imm)); \
1174         } while (0)
1175
1176 #define x86_branch(inst,cond,target,is_signed)  \
1177         do {    \
1178                 int offset = (target) - (inst) - 2;     \
1179                 if (x86_is_imm8 ((offset)))     \
1180                         x86_branch8 ((inst), (cond), offset, (is_signed));      \
1181                 else {  \
1182                         offset -= 4;    \
1183                         x86_branch32 ((inst), (cond), offset, (is_signed));     \
1184                 }       \
1185         } while (0)
1186
1187 #define x86_branch_disp(inst,cond,disp,is_signed)       \
1188         do {    \
1189                 int offset = (disp) - 2;        \
1190                 if (x86_is_imm8 ((offset)))     \
1191                         x86_branch8 ((inst), (cond), offset, (is_signed));      \
1192                 else {  \
1193                         offset -= 4;    \
1194                         x86_branch32 ((inst), (cond), offset, (is_signed));     \
1195                 }       \
1196         } while (0)
1197
1198 #define x86_set_reg(inst,cond,reg,is_signed)    \
1199         do {    \
1200                 *(inst)++ = (unsigned char)0x0f;        \
1201                 if ((is_signed))        \
1202                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
1203                 else    \
1204                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
1205                 x86_reg_emit ((inst), 0, (reg));        \
1206         } while (0)
1207
1208 #define x86_set_mem(inst,cond,mem,is_signed)    \
1209         do {    \
1210                 *(inst)++ = (unsigned char)0x0f;        \
1211                 if ((is_signed))        \
1212                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
1213                 else    \
1214                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
1215                 x86_mem_emit ((inst), 0, (mem));        \
1216         } while (0)
1217
1218 #define x86_set_membase(inst,cond,basereg,disp,is_signed)       \
1219         do {    \
1220                 *(inst)++ = (unsigned char)0x0f;        \
1221                 if ((is_signed))        \
1222                         *(inst)++ = x86_cc_signed_map [(cond)] + 0x20;  \
1223                 else    \
1224                         *(inst)++ = x86_cc_unsigned_map [(cond)] + 0x20;        \
1225                 x86_membase_emit ((inst), 0, (basereg), (disp));        \
1226         } while (0)
1227
1228 #define x86_call_imm(inst,disp) \
1229         do {    \
1230                 *(inst)++ = (unsigned char)0xe8;        \
1231                 x86_imm_emit32 ((inst), (int)(disp));   \
1232         } while (0)
1233
1234 #define x86_call_reg(inst,reg)  \
1235         do {    \
1236                 *(inst)++ = (unsigned char)0xff;        \
1237                 x86_reg_emit ((inst), 2, (reg));        \
1238         } while (0)
1239
1240 #define x86_call_mem(inst,mem)  \
1241         do {    \
1242                 *(inst)++ = (unsigned char)0xff;        \
1243                 x86_mem_emit ((inst), 2, (mem));        \
1244         } while (0)
1245
1246 #define x86_call_membase(inst,basereg,disp)     \
1247         do {    \
1248                 *(inst)++ = (unsigned char)0xff;        \
1249                 x86_membase_emit ((inst), 2, (basereg), (disp));        \
1250         } while (0)
1251
1252 #define x86_call_code(inst,target)      \
1253         do {    \
1254                 int offset = (unsigned char*)(target) - (inst); \
1255                 offset -= 5;    \
1256                 x86_call_imm ((inst), offset);  \
1257         } while (0)
1258
1259 #define x86_ret(inst) do { *(inst)++ = (unsigned char)0xc3; } while (0)
1260
1261 #define x86_ret_imm(inst,imm)   \
1262         do {    \
1263                 if ((imm) == 0) {       \
1264                         x86_ret ((inst));       \
1265                 } else {        \
1266                         *(inst)++ = (unsigned char)0xc2;        \
1267                         x86_imm_emit16 ((inst), (imm)); \
1268                 }       \
1269         } while (0)
1270
1271 #define x86_cmov_reg(inst,cond,is_signed,dreg,reg)      \
1272         do {    \
1273                 *(inst)++ = (unsigned char) 0x0f;       \
1274                 if ((is_signed))        \
1275                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
1276                 else    \
1277                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
1278                 x86_reg_emit ((inst), (dreg), (reg));   \
1279         } while (0)
1280
1281 #define x86_cmov_mem(inst,cond,is_signed,reg,mem)       \
1282         do {    \
1283                 *(inst)++ = (unsigned char) 0x0f;       \
1284                 if ((is_signed))        \
1285                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
1286                 else    \
1287                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
1288                 x86_mem_emit ((inst), (reg), (mem));    \
1289         } while (0)
1290
1291 #define x86_cmov_membase(inst,cond,is_signed,reg,basereg,disp)  \
1292         do {    \
1293                 *(inst)++ = (unsigned char) 0x0f;       \
1294                 if ((is_signed))        \
1295                         *(inst)++ = x86_cc_signed_map [(cond)] - 0x30;  \
1296                 else    \
1297                         *(inst)++ = x86_cc_unsigned_map [(cond)] - 0x30;        \
1298                 x86_membase_emit ((inst), (reg), (basereg), (disp));    \
1299         } while (0)
1300
1301 #define x86_enter(inst,framesize)       \
1302         do {    \
1303                 *(inst)++ = (unsigned char)0xc8;        \
1304                 x86_imm_emit16 ((inst), (framesize));   \
1305                 *(inst)++ = 0;  \
1306         } while (0)
1307
1308 #define x86_leave(inst) do { *(inst)++ = (unsigned char)0xc9; } while (0)
1309 #define x86_sahf(inst)  do { *(inst)++ = (unsigned char)0x9e; } while (0)
1310
1311 #define x86_fsin(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfe; } while (0)
1312 #define x86_fcos(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xff; } while (0)
1313 #define x86_fabs(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xe1; } while (0)
1314 #define x86_fpatan(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf3; } while (0)
1315 #define x86_fprem(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf8; } while (0)
1316 #define x86_fprem1(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf5; } while (0)
1317 #define x86_frndint(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfc; } while (0)
1318 #define x86_fsqrt(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xfa; } while (0)
1319 #define x86_fptan(inst) do { *(inst)++ = (unsigned char)0xd9; *(inst)++ = (unsigned char)0xf2; } while (0)
1320
1321 #define x86_padding(inst,size)  \
1322         do {    \
1323                 switch ((size)) {       \
1324                 case 1: x86_nop ((inst)); break;        \
1325                 case 2: *(inst)++ = 0x8b;       \
1326                         *(inst)++ = 0xc0; break;        \
1327                 case 3: *(inst)++ = 0x8d; *(inst)++ = 0x6d;     \
1328                         *(inst)++ = 0x00; break;        \
1329                 case 4: *(inst)++ = 0x8d; *(inst)++ = 0x64;     \
1330                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
1331                         break;  \
1332                 case 5: *(inst)++ = 0x8d; *(inst)++ = 0x64;     \
1333                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
1334                         x86_nop ((inst)); break;        \
1335                 case 6: *(inst)++ = 0x8d; *(inst)++ = 0xad;     \
1336                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
1337                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
1338                         break;  \
1339                 case 7: *(inst)++ = 0x8d; *(inst)++ = 0xa4;     \
1340                         *(inst)++ = 0x24; *(inst)++ = 0x00;     \
1341                         *(inst)++ = 0x00; *(inst)++ = 0x00;     \
1342                         *(inst)++ = 0x00; break;        \
1343                 default: assert (0);    \
1344                 }       \
1345         } while (0)
1346
1347 #define x86_prolog(inst,frame_size,reg_mask)    \
1348         do {    \
1349                 unsigned i, m = 1;      \
1350                 x86_enter ((inst), (frame_size));       \
1351                 for (i = 0; i < X86_NREG; ++i, m <<= 1) {       \
1352                         if ((reg_mask) & m)     \
1353                                 x86_push_reg ((inst), i);       \
1354                 }       \
1355         } while (0)
1356
1357 #define x86_epilog(inst,reg_mask)       \
1358         do {    \
1359                 unsigned i, m = 1 << X86_EDI;   \
1360                 for (i = X86_EDI; m != 0; i--, m=m>>1) {        \
1361                         if ((reg_mask) & m)     \
1362                                 x86_pop_reg ((inst), i);        \
1363                 }       \
1364                 x86_leave ((inst));     \
1365                 x86_ret ((inst));       \
1366         } while (0)
1367
1368 #endif // X86_H