mono/arch/amd64/amd64-codegen.h

   1 /*
   2  * amd64-codegen.h: Macros for generating amd64 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  *   Zalman Stern
  11  *
  12  * Copyright (C)  2000 Intel Corporation.  All rights reserved.
  13  * Copyright (C)  2001, 2002 Ximian, Inc.
  14  */
  15
  16 #ifndef AMD64_H
  17 #define AMD64_H
  18
  19 #include <glib.h>
  20
  21 typedef enum {
  22         AMD64_RAX = 0,
  23         AMD64_RCX = 1,
  24         AMD64_RDX = 2,
  25         AMD64_RBX = 3,
  26         AMD64_RSP = 4,
  27         AMD64_RBP = 5,
  28         AMD64_RSI = 6,
  29         AMD64_RDI = 7,
  30         AMD64_R8 = 8,
  31         AMD64_R9 = 9,
  32         AMD64_R10 = 10,
  33         AMD64_R11 = 11,
  34         AMD64_R12 = 12,
  35         AMD64_R13 = 13,
  36         AMD64_R14 = 14,
  37         AMD64_R15 = 15,
  38         AMD64_RIP = 16,
  39         AMD64_NREG
  40 } AMD64_Reg_No;
  41
  42 typedef enum {
  43         AMD64_XMM0 = 0,
  44         AMD64_XMM1 = 1,
  45         AMD64_XMM2 = 2,
  46         AMD64_XMM3 = 3,
  47         AMD64_XMM4 = 4,
  48         AMD64_XMM5 = 5,
  49         AMD64_XMM6 = 6,
  50         AMD64_XMM7 = 7,
  51         AMD64_XMM8 = 8,
  52         AMD64_XMM9 = 9,
  53         AMD64_XMM10 = 10,
  54         AMD64_XMM11 = 11,
  55         AMD64_XMM12 = 12,
  56         AMD64_XMM13 = 13,
  57         AMD64_XMM14 = 14,
  58         AMD64_XMM15 = 15,
  59         AMD64_XMM_NREG = 16,
  60 } AMD64_XMM_Reg_No;
  61
  62 typedef enum
  63 {
  64   AMD64_REX_B = 1, /* The register in r/m field, base register in SIB byte, or reg in opcode is 8-15 rather than 0-7 */
  65   AMD64_REX_X = 2, /* The index register in SIB byte is 8-15 rather than 0-7 */
  66   AMD64_REX_R = 4, /* The reg field of ModRM byte is 8-15 rather than 0-7 */
  67   AMD64_REX_W = 8  /* Opeartion is 64-bits instead of 32 (default) or 16 (with 0x66 prefix) */
  68 } AMD64_REX_Bits;
  69
  70 #if defined(__default_codegen__)
  71
  72 #define amd64_codegen_pre(inst)
  73 #define amd64_codegen_post(inst)
  74
  75 #elif defined(__native_client_codegen__)
  76
  77 #define amd64_codegen_pre(inst) guint8* _codegen_start = (inst); amd64_nacl_instruction_pre();
  78 #define amd64_codegen_post(inst) (amd64_nacl_instruction_post(&_codegen_start, &(inst)), _codegen_start);
  79
  80 /* Because of rex prefixes, etc, call sequences are not constant size.  */
  81 /* These pre- and post-sequence hooks remedy this by aligning the call  */
  82 /* sequence after we emit it, since we will know the exact size then.   */
  83 #define amd64_call_sequence_pre(inst) guint8* _code_start = (inst);
  84 #define amd64_call_sequence_post(inst) \
  85   (mono_nacl_align_call(&_code_start, &(inst)), _code_start);
  86
  87 /* Native client can load/store using one of the following registers     */
  88 /* as a base: rip, r15, rbp, rsp.  Any other base register needs to have */
  89 /* its upper 32 bits cleared and reference memory using r15 as the base. */
  90 #define amd64_is_valid_nacl_base(reg) \
  91   ((reg) == AMD64_RIP || (reg) == AMD64_R15 || \
  92    (reg) == AMD64_RBP || (reg) == AMD64_RSP)
  93
  94 #endif /*__native_client_codegen__*/
  95
  96 #ifdef TARGET_WIN32
  97 #define AMD64_ARG_REG1 AMD64_RCX
  98 #define AMD64_ARG_REG2 AMD64_RDX
  99 #define AMD64_ARG_REG3 AMD64_R8
 100 #define AMD64_ARG_REG4 AMD64_R9
 101 #else
 102 #define AMD64_ARG_REG1 AMD64_RDI
 103 #define AMD64_ARG_REG2 AMD64_RSI
 104 #define AMD64_ARG_REG3 AMD64_RDX
 105 #define AMD64_ARG_REG4 AMD64_RCX
 106 #endif
 107
 108 #ifdef TARGET_WIN32
 109 #define AMD64_CALLEE_REGS ((1<<AMD64_RAX) | (1<<AMD64_RCX) | (1<<AMD64_RDX) | (1<<AMD64_R8) | (1<<AMD64_R9) | (1<<AMD64_R10))
 110 #define AMD64_IS_CALLEE_REG(reg)  (AMD64_CALLEE_REGS & (1 << (reg)))
 111
 112 #define AMD64_ARGUMENT_REGS ((1<<AMD64_RDX) | (1<<AMD64_RCX) | (1<<AMD64_R8) | (1<<AMD64_R9))
 113 #define AMD64_IS_ARGUMENT_REG(reg) (AMD64_ARGUMENT_REGS & (1 << (reg)))
 114
 115 #define AMD64_CALLEE_SAVED_REGS ((1<<AMD64_RDI) | (1<<AMD64_RSI) | (1<<AMD64_RBX) | (1<<AMD64_R12) | (1<<AMD64_R13) | (1<<AMD64_R14) | (1<<AMD64_R15) | (1<<AMD64_RBP))
 116 #define AMD64_IS_CALLEE_SAVED_REG(reg) (AMD64_CALLEE_SAVED_REGS & (1 << (reg)))
 117 #elif defined(__native_client_codegen__)
 118 /* AMD64 Native Client code may not write R15 */
 119 #define AMD64_CALLEE_REGS ((1<<AMD64_RAX) | (1<<AMD64_RCX) | (1<<AMD64_RDX) | (1<<AMD64_RSI) | (1<<AMD64_RDI) | (1<<AMD64_R8) | (1<<AMD64_R9) | (1<<AMD64_R10))
 120 #define AMD64_IS_CALLEE_REG(reg)  (AMD64_CALLEE_REGS & (1 << (reg)))
 121
 122 #define AMD64_ARGUMENT_REGS ((1<<AMD64_RDI) | (1<<AMD64_RSI) | (1<<AMD64_RDX) | (1<<AMD64_RCX) | (1<<AMD64_R8) | (1<<AMD64_R9))
 123 #define AMD64_IS_ARGUMENT_REG(reg) (AMD64_ARGUMENT_REGS & (1 << (reg)))
 124
 125 #define AMD64_CALLEE_SAVED_REGS ((1<<AMD64_RBX) | (1<<AMD64_R12) | (1<<AMD64_R13) | (1<<AMD64_R14) | (1<<AMD64_RBP))
 126 #define AMD64_IS_CALLEE_SAVED_REG(reg) (AMD64_CALLEE_SAVED_REGS & (1 << (reg)))
 127 #else
 128 #define AMD64_CALLEE_REGS ((1<<AMD64_RAX) | (1<<AMD64_RCX) | (1<<AMD64_RDX) | (1<<AMD64_RSI) | (1<<AMD64_RDI) | (1<<AMD64_R8) | (1<<AMD64_R9) | (1<<AMD64_R10))
 129 #define AMD64_IS_CALLEE_REG(reg)  (AMD64_CALLEE_REGS & (1 << (reg)))
 130
 131 #define AMD64_ARGUMENT_REGS ((1<<AMD64_RDI) | (1<<AMD64_RSI) | (1<<AMD64_RDX) | (1<<AMD64_RCX) | (1<<AMD64_R8) | (1<<AMD64_R9))
 132 #define AMD64_IS_ARGUMENT_REG(reg) (AMD64_ARGUMENT_REGS & (1 << (reg)))
 133
 134 #define AMD64_CALLEE_SAVED_REGS ((1<<AMD64_RBX) | (1<<AMD64_R12) | (1<<AMD64_R13) | (1<<AMD64_R14) | (1<<AMD64_R15) | (1<<AMD64_RBP))
 135 #define AMD64_IS_CALLEE_SAVED_REG(reg) (AMD64_CALLEE_SAVED_REGS & (1 << (reg)))
 136 #endif
 137
 138 #define AMD64_REX(bits) ((unsigned char)(0x40 | (bits)))
 139 #if defined(__default_codegen__)
 140 #define amd64_emit_rex(inst, width, reg_modrm, reg_index, reg_rm_base_opcode) do \
 141         { \
 142                 unsigned char _amd64_rex_bits = \
 143                         (((width) > 4) ? AMD64_REX_W : 0) | \
 144                         (((reg_modrm) > 7) ? AMD64_REX_R : 0) | \
 145                         (((reg_index) > 7) ? AMD64_REX_X : 0) | \
 146                         (((reg_rm_base_opcode) > 7) ? AMD64_REX_B : 0); \
 147                 if ((_amd64_rex_bits != 0) || (((width) == 1))) *(inst)++ = AMD64_REX(_amd64_rex_bits); \
 148         } while (0)
 149 #elif defined(__native_client_codegen__)
 150 #define amd64_emit_rex(inst, width, reg_modrm, reg_index, reg_rm_base_opcode) do \
 151         { \
 152                 unsigned char _amd64_rex_bits = \
 153                         (((width) > 4) ? AMD64_REX_W : 0) | \
 154                         (((reg_modrm) > 7) ? AMD64_REX_R : 0) | \
 155                         (((reg_index) > 7) ? AMD64_REX_X : 0) | \
 156                         (((reg_rm_base_opcode) > 7) ? AMD64_REX_B : 0); \
 157                 amd64_nacl_tag_rex((inst)); \
 158                 if ((_amd64_rex_bits != 0) || (((width) == 1))) *(inst)++ = AMD64_REX(_amd64_rex_bits); \
 159         } while (0)
 160 #endif
 161
 162 typedef union {
 163         guint64 val;
 164         unsigned char b [8];
 165 } amd64_imm_buf;
 166
 167 #include "../x86/x86-codegen.h"
 168
 169 /* In 64 bit mode, all registers have a low byte subregister */
 170 #undef X86_IS_BYTE_REG
 171 #define X86_IS_BYTE_REG(reg) 1
 172
 173 #define amd64_modrm_mod(modrm) ((modrm) >> 6)
 174 #define amd64_modrm_reg(modrm) (((modrm) >> 3) & 0x7)
 175 #define amd64_modrm_rm(modrm) ((modrm) & 0x7)
 176
 177 #define amd64_rex_r(rex) ((((rex) >> 2) & 0x1) << 3)
 178 #define amd64_rex_x(rex) ((((rex) >> 1) & 0x1) << 3)
 179 #define amd64_rex_b(rex) ((((rex) >> 0) & 0x1) << 3)
 180
 181 #define amd64_sib_scale(sib) ((sib) >> 6)
 182 #define amd64_sib_index(sib) (((sib) >> 3) & 0x7)
 183 #define amd64_sib_base(sib) ((sib) & 0x7)
 184
 185 #define amd64_is_imm32(val) ((gint64)val >= -((gint64)1<<31) && (gint64)val <= (((gint64)1<<31)-1))
 186
 187 #define x86_imm_emit64(inst,imm)     \
 188         do {    \
 189                         amd64_imm_buf imb;      \
 190                         imb.val = (guint64) (imm);      \
 191                         *(inst)++ = imb.b [0];  \
 192                         *(inst)++ = imb.b [1];  \
 193                         *(inst)++ = imb.b [2];  \
 194                         *(inst)++ = imb.b [3];  \
 195                         *(inst)++ = imb.b [4];  \
 196                         *(inst)++ = imb.b [5];  \
 197                         *(inst)++ = imb.b [6];  \
 198                         *(inst)++ = imb.b [7];  \
 199         } while (0)
 200
 201 #define amd64_membase_emit(inst,reg,basereg,disp) do { \
 202         if ((basereg) == AMD64_RIP) { \
 203         x86_address_byte ((inst), 0, (reg)&0x7, 5); \
 204         x86_imm_emit32 ((inst), (disp)); \
 205     } \
 206         else \
 207                 x86_membase_emit ((inst),(reg)&0x7, (basereg)&0x7, (disp)); \
 208 } while (0)
 209
 210 #define amd64_alu_reg_imm_size_body(inst,opc,reg,imm,size) \
 211         do {    \
 212                 if (x86_is_imm8((imm))) {       \
 213                         amd64_emit_rex(inst, size, 0, 0, (reg)); \
 214                         *(inst)++ = (unsigned char)0x83;        \
 215                         x86_reg_emit ((inst), (opc), (reg));    \
 216                         x86_imm_emit8 ((inst), (imm));  \
 217                 } else if ((reg) == X86_EAX) {  \
 218                         amd64_emit_rex(inst, size, 0, 0, 0); \
 219                         *(inst)++ = (((unsigned char)(opc)) << 3) + 5;  \
 220                         x86_imm_emit32 ((inst), (imm)); \
 221                 } else {        \
 222                         amd64_emit_rex(inst, size, 0, 0, (reg)); \
 223                         *(inst)++ = (unsigned char)0x81;        \
 224                         x86_reg_emit ((inst), (opc), (reg));    \
 225                         x86_imm_emit32 ((inst), (imm)); \
 226                 }       \
 227         } while (0)
 228
 229 #define amd64_alu_reg_reg_size_body(inst,opc,dreg,reg,size)     \
 230         do {    \
 231                 amd64_emit_rex(inst, size, (dreg), 0, (reg)); \
 232                 *(inst)++ = (((unsigned char)(opc)) << 3) + 3;  \
 233                 x86_reg_emit ((inst), (dreg), (reg));   \
 234         } while (0)
 235
 236 #if defined(__default_codegen__)
 237
 238 #define amd64_alu_reg_imm_size(inst,opc,reg,imm,size) \
 239         amd64_alu_reg_imm_size_body((inst), (opc), (reg), (imm), (size))
 240
 241 #define amd64_alu_reg_reg_size(inst,opc,dreg,reg,size) \
 242                 amd64_alu_reg_reg_size_body((inst), (opc), (dreg), (reg), (size))
 243
 244 #elif defined(__native_client_codegen__)
 245 /* NaCl modules may not directly update RSP or RBP other than direct copies */
 246 /* between them. Instead the lower 4 bytes are updated and then added to R15 */
 247 #define amd64_is_nacl_stack_reg(reg) (((reg) == AMD64_RSP) || ((reg) == AMD64_RBP))
 248
 249 #define amd64_alu_reg_imm_size(inst,opc,reg,imm,size)   \
 250         do{ \
 251                 amd64_codegen_pre(inst);                \
 252                 if (amd64_is_nacl_stack_reg(reg)) { \
 253                         if (((opc) != X86_ADD) && ((opc) != X86_SUB)) \
 254                                 g_assert_not_reached(); \
 255                         amd64_alu_reg_imm_size_body((inst), (opc), (reg), (imm), 4); \
 256                         /* Use LEA instead of ADD to preserve flags */ \
 257                         amd64_lea_memindex_size((inst), (reg), (reg), 0, AMD64_R15, 0, 8); \
 258                 } else { \
 259                         amd64_alu_reg_imm_size_body((inst), (opc), (reg), (imm), (size)); \
 260                 } \
 261                 amd64_codegen_post(inst);               \
 262         } while(0)
 263
 264 #define amd64_alu_reg_reg_size(inst,opc,dreg,reg,size) \
 265         do { \
 266                 amd64_codegen_pre(inst);                \
 267                 if (amd64_is_nacl_stack_reg((dreg)) && ((reg) != AMD64_R15)) { \
 268                         if (((opc) != X86_ADD && (opc) != X86_SUB)) \
 269                                 g_assert_not_reached(); \
 270                         amd64_alu_reg_reg_size_body((inst), (opc), (dreg), (reg), 4); \
 271                         /* Use LEA instead of ADD to preserve flags */ \
 272                         amd64_lea_memindex_size((inst), (dreg), (dreg), 0, AMD64_R15, 0, 8); \
 273                 } else { \
 274                         amd64_alu_reg_reg_size_body((inst), (opc), (dreg), (reg), (size)); \
 275                 } \
 276                 amd64_codegen_post(inst);               \
 277         } while (0)
 278
 279 #endif /*__native_client_codegen__*/
 280
 281 #define amd64_alu_reg_imm(inst,opc,reg,imm) amd64_alu_reg_imm_size((inst),(opc),(reg),(imm),8)
 282
 283 #define amd64_alu_reg_reg(inst,opc,dreg,reg) amd64_alu_reg_reg_size ((inst),(opc),(dreg),(reg),8)
 284
 285 #define amd64_mov_regp_reg(inst,regp,reg,size)  \
 286         do {    \
 287                 amd64_codegen_pre(inst); \
 288                 if ((size) == 2) \
 289                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 290                 amd64_emit_rex(inst, (size), (reg), 0, (regp)); \
 291                 switch ((size)) {       \
 292                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 293                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x89; break; \
 294                 default: assert (0);    \
 295                 }       \
 296                 x86_regp_emit ((inst), (reg), (regp));  \
 297                 amd64_codegen_post(inst); \
 298         } while (0)
 299
 300 #define amd64_mov_membase_reg(inst,basereg,disp,reg,size)       \
 301         do {    \
 302                 amd64_codegen_pre(inst); \
 303                 if ((size) == 2) \
 304                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 305                 amd64_emit_rex(inst, (size), (reg), 0, (basereg)); \
 306                 switch ((size)) {       \
 307                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 308                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x89; break; \
 309                 default: assert (0);    \
 310                 }       \
 311                 x86_membase_emit ((inst), ((reg)&0x7), ((basereg)&0x7), (disp));        \
 312                 amd64_codegen_post(inst); \
 313         } while (0)
 314
 315 #define amd64_mov_mem_reg(inst,mem,reg,size)    \
 316         do {    \
 317                 amd64_codegen_pre(inst); \
 318                 if ((size) == 2) \
 319                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 320                 amd64_emit_rex(inst, (size), (reg), 0, 0); \
 321                 switch ((size)) {       \
 322                 case 1: *(inst)++ = (unsigned char)0x88; break; \
 323                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x89; break; \
 324                 default: assert (0);    \
 325                 }       \
 326                 x86_address_byte ((inst), 0, (reg), 4); \
 327                 x86_address_byte ((inst), 0, 4, 5); \
 328                 x86_imm_emit32 ((inst), (mem)); \
 329                 amd64_codegen_post(inst); \
 330         } while (0)
 331
 332 #define amd64_mov_reg_reg(inst,dreg,reg,size)   \
 333         do {    \
 334                 amd64_codegen_pre(inst); \
 335                 if ((size) == 2) \
 336                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 337                 amd64_emit_rex(inst, (size), (dreg), 0, (reg)); \
 338                 switch ((size)) {       \
 339                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 340                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x8b; break; \
 341                 default: assert (0);    \
 342                 }       \
 343                 x86_reg_emit ((inst), (dreg), (reg));   \
 344                 amd64_codegen_post(inst); \
 345         } while (0)
 346
 347 #define amd64_mov_reg_mem_body(inst,reg,mem,size)       \
 348         do {    \
 349                 amd64_codegen_pre(inst); \
 350                 if ((size) == 2) \
 351                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 352                 amd64_emit_rex(inst, (size), (reg), 0, 0); \
 353                 switch ((size)) {       \
 354                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 355                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x8b; break; \
 356                 default: assert (0);    \
 357                 }       \
 358                 x86_address_byte ((inst), 0, (reg), 4); \
 359                 x86_address_byte ((inst), 0, 4, 5); \
 360                 x86_imm_emit32 ((inst), (mem)); \
 361                 amd64_codegen_post(inst); \
 362         } while (0)
 363
 364 #if defined(__default_codegen__)
 365 #define amd64_mov_reg_mem(inst,reg,mem,size)    \
 366         do {    \
 367                 amd64_mov_reg_mem_body((inst),(reg),(mem),(size)); \
 368         } while (0)
 369 #elif defined(__native_client_codegen__)
 370 /* We have to re-base memory reads because memory isn't zero based. */
 371 #define amd64_mov_reg_mem(inst,reg,mem,size)    \
 372         do {    \
 373                 amd64_mov_reg_membase((inst),(reg),AMD64_R15,(mem),(size)); \
 374         } while (0)
 375 #endif /* __native_client_codegen__ */
 376
 377 #define amd64_mov_reg_membase_body(inst,reg,basereg,disp,size)  \
 378         do {    \
 379                 if ((size) == 2) \
 380                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 381                 amd64_emit_rex(inst, (size), (reg), 0, (basereg)); \
 382                 switch ((size)) {       \
 383                 case 1: *(inst)++ = (unsigned char)0x8a; break; \
 384                 case 2: case 4: case 8: *(inst)++ = (unsigned char)0x8b; break; \
 385                 default: assert (0);    \
 386                 }       \
 387                 amd64_membase_emit ((inst), (reg), (basereg), (disp));  \
 388         } while (0)
 389
 390 #define amd64_mov_reg_memindex_size_body(inst,reg,basereg,disp,indexreg,shift,size) \
 391         do { \
 392                 amd64_emit_rex ((inst),(size),(reg),(indexreg),(basereg)); \
 393                 x86_mov_reg_memindex((inst),((reg)&0x7),((basereg)&0x7),(disp),((indexreg)&0x7),(shift),(size) == 8 ? 4 : (size)); \
 394         } while (0)
 395
 396 #if defined(__default_codegen__)
 397
 398 #define amd64_mov_reg_memindex_size(inst,reg,basereg,disp,indexreg,shift,size) \
 399         amd64_mov_reg_memindex_size_body((inst),(reg),(basereg),(disp),(indexreg),(shift),(size))
 400 #define amd64_mov_reg_membase(inst,reg,basereg,disp,size)       \
 401         do {    \
 402                 amd64_mov_reg_membase_body((inst), (reg), (basereg), (disp), (size)); \
 403         } while (0)
 404
 405 #elif defined(__native_client_codegen__)
 406
 407 #define amd64_mov_reg_memindex_size(inst,reg,basereg,disp,indexreg,shift,size) \
 408         do { \
 409                 amd64_codegen_pre(inst); \
 410                 if (amd64_is_nacl_stack_reg((reg))) { \
 411                         /* Clear upper 32 bits with mov of size 4 */ \
 412                         amd64_mov_reg_memindex_size_body((inst), (reg), (basereg), (disp), (indexreg), (shift), 4); \
 413                         /* Add %r15 using LEA to preserve flags */ \
 414                         amd64_lea_memindex_size((inst), (reg), (reg), 0, AMD64_R15, 0, 8); \
 415                 } else { \
 416                         amd64_mov_reg_memindex_size_body((inst), (reg), (basereg), (disp), (indexreg), (shift), (size)); \
 417                 } \
 418                 amd64_codegen_post(inst); \
 419         } while(0)
 420
 421 #define amd64_mov_reg_membase(inst,reg,basereg,disp,size)       \
 422         do {    \
 423                 amd64_codegen_pre(inst); \
 424                 if (amd64_is_nacl_stack_reg((reg))) { \
 425                         /* Clear upper 32 bits with mov of size 4 */ \
 426                         amd64_mov_reg_membase_body((inst), (reg), (basereg), (disp), 4); \
 427                         /* Add %r15 */ \
 428                         amd64_lea_memindex_size((inst), (reg), (reg), 0, AMD64_R15, 0, 8); \
 429                 } else { \
 430                         amd64_mov_reg_membase_body((inst), (reg), (basereg), (disp), (size)); \
 431                 } \
 432                 amd64_codegen_post(inst); \
 433         } while (0)
 434
 435 #endif /*__native_client_codegen__*/
 436
 437 #define amd64_movzx_reg_membase(inst,reg,basereg,disp,size)     \
 438         do {    \
 439                 amd64_codegen_pre(inst); \
 440                 amd64_emit_rex(inst, (size), (reg), 0, (basereg)); \
 441                 switch ((size)) {       \
 442                 case 1: *(inst)++ = (unsigned char)0x0f; *(inst)++ = (unsigned char)0xb6; break;        \
 443                 case 2: *(inst)++ = (unsigned char)0x0f; *(inst)++ = (unsigned char)0xb7; break;        \
 444                 case 4: case 8: *(inst)++ = (unsigned char)0x8b; break; \
 445                 default: assert (0);    \
 446                 }       \
 447                 x86_membase_emit ((inst), ((reg)&0x7), ((basereg)&0x7), (disp));        \
 448                 amd64_codegen_post(inst); \
 449         } while (0)
 450
 451 #define amd64_movsxd_reg_mem(inst,reg,mem) \
 452     do {     \
 453         amd64_codegen_pre(inst); \
 454         amd64_emit_rex(inst,8,(reg),0,0); \
 455         *(inst)++ = (unsigned char)0x63; \
 456         x86_mem_emit ((inst), ((reg)&0x7), (mem)); \
 457         amd64_codegen_post(inst); \
 458     } while (0)
 459
 460 #define amd64_movsxd_reg_membase(inst,reg,basereg,disp) \
 461     do {     \
 462         amd64_codegen_pre(inst); \
 463         amd64_emit_rex(inst,8,(reg),0,(basereg)); \
 464         *(inst)++ = (unsigned char)0x63; \
 465         x86_membase_emit ((inst), ((reg)&0x7), ((basereg)&0x7), (disp)); \
 466         amd64_codegen_post(inst); \
 467     } while (0)
 468
 469 #define amd64_movsxd_reg_reg(inst,dreg,reg) \
 470     do {     \
 471         amd64_codegen_pre(inst); \
 472         amd64_emit_rex(inst,8,(dreg),0,(reg)); \
 473         *(inst)++ = (unsigned char)0x63; \
 474         x86_reg_emit ((inst), (dreg), (reg));   \
 475         amd64_codegen_post(inst); \
 476     } while (0)
 477
 478 /* Pretty much the only instruction that supports a 64-bit immediate. Optimize for common case of
 479  * 32-bit immediate. Pepper with casts to avoid warnings.
 480  */
 481 #define amd64_mov_reg_imm_size(inst,reg,imm,size)       \
 482         do {    \
 483                 amd64_codegen_pre(inst); \
 484                 amd64_emit_rex(inst, (size), 0, 0, (reg)); \
 485                 *(inst)++ = (unsigned char)0xb8 + ((reg) & 0x7);        \
 486                 if ((size) == 8) \
 487                         x86_imm_emit64 ((inst), (guint64)(imm));        \
 488                 else \
 489                         x86_imm_emit32 ((inst), (int)(guint64)(imm));   \
 490                 amd64_codegen_post(inst); \
 491         } while (0)
 492
 493 #define amd64_mov_reg_imm(inst,reg,imm) \
 494         do {    \
 495                 int _amd64_width_temp = ((guint64)(imm) == (guint64)(int)(guint64)(imm)); \
 496                 amd64_codegen_pre(inst); \
 497                 amd64_mov_reg_imm_size ((inst), (reg), (imm), (_amd64_width_temp ? 4 : 8)); \
 498                 amd64_codegen_post(inst); \
 499         } while (0)
 500
 501 #define amd64_set_reg_template(inst,reg) amd64_mov_reg_imm_size ((inst),(reg), 0, 8)
 502
 503 #define amd64_set_template(inst,reg) amd64_set_reg_template((inst),(reg))
 504
 505 #define amd64_mov_membase_imm(inst,basereg,disp,imm,size)       \
 506         do {    \
 507                 amd64_codegen_pre(inst); \
 508                 if ((size) == 2) \
 509                         x86_prefix((inst), X86_OPERAND_PREFIX); \
 510                 amd64_emit_rex(inst, (size) == 1 ? 0 : (size), 0, 0, (basereg)); \
 511                 if ((size) == 1) {      \
 512                         *(inst)++ = (unsigned char)0xc6;        \
 513                         x86_membase_emit ((inst), 0, (basereg) & 0x7, (disp));  \
 514                         x86_imm_emit8 ((inst), (imm));  \
 515                 } else if ((size) == 2) {       \
 516                         *(inst)++ = (unsigned char)0xc7;        \
 517                         x86_membase_emit ((inst), 0, (basereg) & 0x7, (disp));  \
 518                         x86_imm_emit16 ((inst), (imm)); \
 519                 } else {        \
 520                         *(inst)++ = (unsigned char)0xc7;        \
 521                         x86_membase_emit ((inst), 0, (basereg) & 0x7, (disp));  \
 522                         x86_imm_emit32 ((inst), (imm)); \
 523                 }       \
 524                 amd64_codegen_post(inst); \
 525         } while (0)
 526
 527
 528 #define amd64_lea_membase_body(inst,reg,basereg,disp)   \
 529         do {    \
 530                 amd64_emit_rex(inst, 8, (reg), 0, (basereg)); \
 531                 *(inst)++ = (unsigned char)0x8d;        \
 532                 amd64_membase_emit ((inst), (reg), (basereg), (disp));  \
 533         } while (0)
 534
 535 #if defined(__default_codegen__)
 536 #define amd64_lea_membase(inst,reg,basereg,disp) \
 537         amd64_lea_membase_body((inst), (reg), (basereg), (disp))
 538 #elif defined(__native_client_codegen__)
 539 /* NaCl modules may not write directly into RSP/RBP. Instead, use a */
 540 /*  32-bit LEA and add R15 to the effective address */
 541 #define amd64_lea_membase(inst,reg,basereg,disp) \
 542         do { \
 543                 amd64_codegen_pre(inst); \
 544                 if (amd64_is_nacl_stack_reg(reg)) { \
 545                         /* 32-bit LEA */ \
 546                         amd64_emit_rex((inst), 4, (reg), 0, (basereg)); \
 547                         *(inst)++ = (unsigned char)0x8d; \
 548                         amd64_membase_emit((inst), (reg), (basereg), (disp)); \
 549                         /* Use a 64-bit LEA instead of an ADD to preserve flags */ \
 550                         amd64_lea_memindex_size((inst), (reg), (reg), 0, AMD64_R15, 0, 8); \
 551                 } else { \
 552                         amd64_lea_membase_body((inst), (reg), (basereg), (disp)); \
 553                 } \
 554                 amd64_codegen_post(inst); \
 555         } while (0)
 556 #endif /*__native_client_codegen__*/
 557
 558 /* Instruction are implicitly 64-bits so don't generate REX for just the size. */
 559 #define amd64_push_reg(inst,reg)        \
 560         do {    \
 561                 amd64_codegen_pre(inst); \
 562                 amd64_emit_rex(inst, 0, 0, 0, (reg)); \
 563                 *(inst)++ = (unsigned char)0x50 + ((reg) & 0x7);        \
 564                 amd64_codegen_post(inst); \
 565         } while (0)
 566
 567 /* Instruction is implicitly 64-bits so don't generate REX for just the size. */
 568 #define amd64_push_membase(inst,basereg,disp)   \
 569         do {    \
 570                 amd64_codegen_pre(inst); \
 571                 amd64_emit_rex(inst, 0, 0, 0, (basereg)); \
 572                 *(inst)++ = (unsigned char)0xff;        \
 573                 x86_membase_emit ((inst), 6, (basereg) & 0x7, (disp));  \
 574                 amd64_codegen_post(inst); \
 575         } while (0)
 576
 577 #define amd64_pop_reg_body(inst,reg)    \
 578         do {    \
 579                 amd64_codegen_pre(inst);  \
 580                 amd64_emit_rex(inst, 0, 0, 0, (reg)); \
 581                 *(inst)++ = (unsigned char)0x58 + ((reg) & 0x7);        \
 582                 amd64_codegen_post(inst);  \
 583         } while (0)
 584
 585 #if defined(__default_codegen__)
 586
 587 #define amd64_call_reg(inst,reg)        \
 588         do {    \
 589                 amd64_emit_rex(inst, 0, 0, 0, (reg)); \
 590                 *(inst)++ = (unsigned char)0xff;        \
 591                 x86_reg_emit ((inst), 2, ((reg) & 0x7));        \
 592         } while (0)
 593
 594
 595 #define amd64_ret(inst) do { *(inst)++ = (unsigned char)0xc3; } while (0)
 596 #define amd64_leave(inst) do { *(inst)++ = (unsigned char)0xc9; } while (0)
 597
 598 #define amd64_pop_reg(inst,reg) amd64_pop_reg_body((inst), (reg))
 599
 600 #elif defined(__native_client_codegen__)
 601
 602 /* Size is ignored for Native Client jumps, we restrict jumping to 32-bits */
 603 #define amd64_jump_reg_size(inst,reg,size)                                \
 604   do {                                                                    \
 605     amd64_codegen_pre((inst));                                            \
 606     amd64_alu_reg_imm_size((inst), X86_AND, (reg), (nacl_align_byte), 4); \
 607     amd64_alu_reg_reg_size((inst), X86_ADD, (reg), AMD64_R15, 8);         \
 608     amd64_emit_rex ((inst),0,0,0,(reg));                                  \
 609     x86_jump_reg((inst),((reg)&0x7));                                     \
 610     amd64_codegen_post((inst));                                           \
 611   } while (0)
 612
 613 /* Size is ignored for Native Client jumps, we restrict jumping to 32-bits */
 614 #define amd64_jump_mem_size(inst,mem,size)                                \
 615   do {                                                                    \
 616     amd64_codegen_pre((inst));                                            \
 617     amd64_mov_reg_mem((inst), (mem), AMD64_R11, 4);                       \
 618     amd64_jump_reg_size((inst), AMD64_R11, 4);                            \
 619     amd64_codegen_post((inst));                                           \
 620   } while (0)
 621
 622 #define amd64_call_reg_internal(inst,reg)                                 \
 623   do {                                                                    \
 624     amd64_codegen_pre((inst));                                            \
 625     amd64_alu_reg_imm_size((inst), X86_AND, (reg), (nacl_align_byte), 4); \
 626     amd64_alu_reg_reg_size((inst), X86_ADD, (reg), AMD64_R15, 8);         \
 627     amd64_emit_rex((inst), 0, 0, 0, (reg));                               \
 628     x86_call_reg((inst), ((reg) & 0x7));                                  \
 629     amd64_codegen_post((inst));                                           \
 630   } while (0)
 631
 632 #define amd64_call_reg(inst,reg)                                          \
 633   do {                                                                    \
 634     amd64_codegen_pre((inst));                                            \
 635     amd64_call_sequence_pre(inst);                                        \
 636     amd64_call_reg_internal((inst), (reg));                               \
 637     amd64_call_sequence_post(inst);                                       \
 638     amd64_codegen_post((inst));                                           \
 639   } while (0)
 640
 641
 642 #define amd64_ret(inst)                                                   \
 643   do {                                                                    \
 644     amd64_codegen_pre(inst);                                              \
 645     amd64_pop_reg_body((inst), AMD64_R11);                                \
 646     amd64_jump_reg_size((inst), AMD64_R11, 8);                            \
 647     amd64_codegen_post(inst);                                             \
 648   } while (0)
 649
 650 #define amd64_leave(inst)                                                 \
 651   do {                                                                    \
 652     amd64_codegen_pre(inst);                                              \
 653     amd64_mov_reg_reg((inst), AMD64_RSP, AMD64_RBP, 8);                   \
 654     amd64_pop_reg_body((inst), AMD64_R11);                                \
 655     amd64_mov_reg_reg_size((inst), AMD64_RBP, AMD64_R11, 4);              \
 656     amd64_alu_reg_reg_size((inst), X86_ADD, AMD64_RBP, AMD64_R15, 8);     \
 657     amd64_codegen_post(inst);                                             \
 658   } while (0)
 659
 660 #define amd64_pop_reg(inst,reg) \
 661         do { \
 662                 amd64_codegen_pre(inst); \
 663                 if (amd64_is_nacl_stack_reg((reg))) { \
 664                         amd64_pop_reg_body((inst), AMD64_R11); \
 665                         amd64_mov_reg_reg_size((inst), (reg), AMD64_R11, 4); \
 666                         amd64_alu_reg_reg_size((inst), X86_ADD, (reg), AMD64_R15, 8); \
 667                 } else { \
 668                         amd64_pop_reg_body((inst), (reg)); \
 669                 } \
 670                 amd64_codegen_post(inst); \
 671         } while (0)
 672
 673 #endif /*__native_client_codegen__*/
 674
 675 #define amd64_movsd_reg_regp(inst,reg,regp)     \
 676         do {    \
 677                 amd64_codegen_pre(inst); \
 678                 x86_prefix((inst), 0xf2); \
 679                 amd64_emit_rex(inst, 0, (reg), 0, (regp)); \
 680                 *(inst)++ = (unsigned char)0x0f;        \
 681                 *(inst)++ = (unsigned char)0x10;        \
 682                 x86_regp_emit ((inst), (reg) & 0x7, (regp) & 0x7);      \
 683                 amd64_codegen_post(inst); \
 684         } while (0)
 685
 686 #define amd64_movsd_regp_reg(inst,regp,reg)     \
 687         do {    \
 688                 amd64_codegen_pre(inst); \
 689                 x86_prefix((inst), 0xf2); \
 690                 amd64_emit_rex(inst, 0, (reg), 0, (regp)); \
 691                 *(inst)++ = (unsigned char)0x0f;        \
 692                 *(inst)++ = (unsigned char)0x11;        \
 693                 x86_regp_emit ((inst), (reg) & 0x7, (regp) & 0x7);      \
 694                 amd64_codegen_post(inst); \
 695         } while (0)
 696
 697 #define amd64_movss_reg_regp(inst,reg,regp)     \
 698         do {    \
 699                 amd64_codegen_pre(inst); \
 700                 x86_prefix((inst), 0xf3); \
 701                 amd64_emit_rex(inst, 0, (reg), 0, (regp)); \
 702                 *(inst)++ = (unsigned char)0x0f;        \
 703                 *(inst)++ = (unsigned char)0x10;        \
 704                 x86_regp_emit ((inst), (reg) & 0x7, (regp) & 0x7);      \
 705                 amd64_codegen_post(inst); \
 706         } while (0)
 707
 708 #define amd64_movss_regp_reg(inst,regp,reg)     \
 709         do {    \
 710                 amd64_codegen_pre(inst); \
 711                 x86_prefix((inst), 0xf3); \
 712                 amd64_emit_rex(inst, 0, (reg), 0, (regp)); \
 713                 *(inst)++ = (unsigned char)0x0f;        \
 714                 *(inst)++ = (unsigned char)0x11;        \
 715                 x86_regp_emit ((inst), (reg) & 0x7, (regp) & 0x7);      \
 716                 amd64_codegen_post(inst); \
 717         } while (0)
 718
 719 #define amd64_movsd_reg_membase(inst,reg,basereg,disp)  \
 720         do {    \
 721                 amd64_codegen_pre(inst); \
 722                 x86_prefix((inst), 0xf2); \
 723                 amd64_emit_rex(inst, 0, (reg), 0, (basereg)); \
 724                 *(inst)++ = (unsigned char)0x0f;        \
 725                 *(inst)++ = (unsigned char)0x10;        \
 726                 x86_membase_emit ((inst), (reg) & 0x7, (basereg) & 0x7, (disp));        \
 727                 amd64_codegen_post(inst); \
 728         } while (0)
 729
 730 #define amd64_movss_reg_membase(inst,reg,basereg,disp)  \
 731         do {    \
 732                 amd64_codegen_pre(inst); \
 733                 x86_prefix((inst), 0xf3); \
 734                 amd64_emit_rex(inst, 0, (reg), 0, (basereg)); \
 735                 *(inst)++ = (unsigned char)0x0f;        \
 736                 *(inst)++ = (unsigned char)0x10;        \
 737                 x86_membase_emit ((inst), (reg) & 0x7, (basereg) & 0x7, (disp));        \
 738                 amd64_codegen_post(inst); \
 739         } while (0)
 740
 741 #define amd64_movsd_membase_reg(inst,basereg,disp,reg)  \
 742         do {    \
 743                 amd64_codegen_pre(inst); \
 744                 x86_prefix((inst), 0xf2); \
 745                 amd64_emit_rex(inst, 0, (reg), 0, (basereg)); \
 746                 *(inst)++ = (unsigned char)0x0f;        \
 747                 *(inst)++ = (unsigned char)0x11;        \
 748                 x86_membase_emit ((inst), (reg) & 0x7, (basereg) & 0x7, (disp));        \
 749                 amd64_codegen_post(inst); \
 750         } while (0)
 751
 752 #define amd64_movss_membase_reg(inst,basereg,disp,reg)  \
 753         do {    \
 754                 amd64_codegen_pre(inst); \
 755                 x86_prefix((inst), 0xf3); \
 756                 amd64_emit_rex(inst, 0, (reg), 0, (basereg)); \
 757                 *(inst)++ = (unsigned char)0x0f;        \
 758                 *(inst)++ = (unsigned char)0x11;        \
 759                 x86_membase_emit ((inst), (reg) & 0x7, (basereg) & 0x7, (disp));        \
 760                 amd64_codegen_post(inst); \
 761         } while (0)
 762
 763 /* The original inc_reg opcode is used as the REX prefix */
 764 #define amd64_inc_reg_size(inst,reg,size) \
 765         do { \
 766                 amd64_codegen_pre(inst); \
 767                 amd64_emit_rex ((inst),(size),0,0,(reg)); \
 768                 *(inst)++ = (unsigned char)0xff; \
 769                 x86_reg_emit ((inst),0,(reg) & 0x7); \
 770                 amd64_codegen_post(inst); \
 771         } while (0)
 772
 773 #define amd64_dec_reg_size(inst,reg,size) \
 774         do { \
 775                 amd64_codegen_pre(inst); \
 776                 amd64_emit_rex ((inst),(size),0,0,(reg)); \
 777                 *(inst)++ = (unsigned char)0xff; \
 778                 x86_reg_emit ((inst),1,(reg) & 0x7); \
 779                 amd64_codegen_post(inst); \
 780         } while (0)
 781
 782 #define amd64_fld_membase_size(inst,basereg,disp,is_double,size) do { \
 783         amd64_codegen_pre(inst); \
 784         amd64_emit_rex ((inst),0,0,0,(basereg)); \
 785         *(inst)++ = (is_double) ? (unsigned char)0xdd : (unsigned char)0xd9;    \
 786         amd64_membase_emit ((inst), 0, (basereg), (disp));      \
 787         amd64_codegen_post(inst); \
 788 } while (0)
 789
 790 #if defined (__default_codegen__)
 791
 792 /* From the AMD64 Software Optimization Manual */
 793 #define amd64_padding_size(inst,size) \
 794     do { \
 795             switch ((size)) {                                                             \
 796         case 1: *(inst)++ = 0x90; break;                                                  \
 797         case 2: *(inst)++ = 0x66; *(inst)++ = 0x90; break;                        \
 798         case 3: *(inst)++ = 0x66; *(inst)++ = 0x66; *(inst)++ = 0x90; break; \
 799                 default: amd64_emit_rex ((inst),8,0,0,0); x86_padding ((inst), (size) - 1); \
 800                 }; \
 801                 } while (0)
 802
 803 #define amd64_call_membase_size(inst,basereg,disp,size) do { amd64_emit_rex ((inst),0,0,0,(basereg)); *(inst)++ = (unsigned char)0xff; amd64_membase_emit ((inst),2, (basereg),(disp)); } while (0)
 804 #define amd64_jump_membase_size(inst,basereg,disp,size) do { amd64_emit_rex ((inst),0,0,0,(basereg)); *(inst)++ = (unsigned char)0xff; amd64_membase_emit ((inst), 4, (basereg), (disp)); } while (0)
 805
 806 #define amd64_jump_code_size(inst,target,size) do { \
 807         if (amd64_is_imm32 ((gint64)(target) - (gint64)(inst))) {               \
 808                 x86_jump_code((inst),(target));                                                                 \
 809         } else {                                                                                                                        \
 810             amd64_jump_membase ((inst), AMD64_RIP, 0);                                                  \
 811                 *(guint64*)(inst) = (guint64)(target);                                                  \
 812                 (inst) += 8; \
 813         } \
 814 } while (0)
 815
 816 #elif defined(__native_client_codegen__)
 817
 818 /* The 3-7 byte NOP sequences in amd64_padding_size below are all illegal in */
 819 /* 64-bit Native Client because they load into rSP/rBP or use duplicate */
 820 /* prefixes. Instead we use the NOPs recommended in Section 3.5.1.8 of the */
 821 /* Intel64 and IA-32 Architectures Optimization Reference Manual and */
 822 /* Section 4.13 of AMD Software Optimization Guide for Family 10h Processors. */
 823
 824 #define amd64_padding_size(inst,size) \
 825         do { \
 826                 unsigned char *code_start = (inst); \
 827                 switch ((size)) { \
 828                         /* xchg %eax,%eax, recognized by hardware as a NOP */ \
 829                         case 1: *(inst)++ = 0x90; break; \
 830                         /* xchg %ax,%ax */ \
 831                         case 2: *(inst)++ = 0x66; *(inst)++ = 0x90; \
 832                                 break; \
 833                         /* nop (%rax) */ \
 834                         case 3: *(inst)++ = 0x0f; *(inst)++ = 0x1f; \
 835                                 *(inst)++ = 0x00; \
 836                                 break; \
 837                         /* nop 0x0(%rax) */ \
 838                         case 4: *(inst)++ = 0x0f; *(inst)++ = 0x1f; \
 839                                 x86_address_byte ((inst), 1, 0, AMD64_RAX);     \
 840                                 x86_imm_emit8 ((inst), 0);      \
 841                                 break; \
 842                         /* nop 0x0(%rax,%rax) */ \
 843                         case 5: *(inst)++ = 0x0f; *(inst)++ = 0x1f; \
 844                                 x86_address_byte ((inst), 1, 0, 4);     \
 845                                 x86_address_byte ((inst), 0, AMD64_RAX, AMD64_RAX);     \
 846                                 x86_imm_emit8 ((inst), 0);      \
 847                                 break; \
 848                         /* nopw 0x0(%rax,%rax) */ \
 849                         case 6: *(inst)++ = 0x66; *(inst)++ = 0x0f; \
 850                                 *(inst)++ = 0x1f; \
 851                                 x86_address_byte ((inst), 1, 0, 4);     \
 852                                 x86_address_byte ((inst), 0, AMD64_RAX, AMD64_RAX);     \
 853                                 x86_imm_emit8 ((inst), 0);      \
 854                                 break; \
 855                         /* nop 0x0(%rax) (32-bit displacement) */ \
 856                         case 7: *(inst)++ = 0x0f; *(inst)++ = 0x1f; \
 857                                 x86_address_byte ((inst), 2, 0, AMD64_RAX);     \
 858                                 x86_imm_emit32((inst), 0); \
 859                                 break; \
 860                         /* nop 0x0(%rax,%rax) (32-bit displacement) */ \
 861                         case 8: *(inst)++ = 0x0f; *(inst)++ = 0x1f; \
 862                                 x86_address_byte ((inst), 2, 0, 4);     \
 863                                 x86_address_byte ((inst), 0, AMD64_RAX, AMD64_RAX);     \
 864                                 x86_imm_emit32 ((inst), 0);     \
 865                                 break; \
 866                         default: \
 867                                 g_assert_not_reached(); \
 868                 } \
 869                 g_assert(code_start + (size) == (unsigned char *)(inst)); \
 870         } while (0)
 871
 872
 873 /* Size is ignored for Native Client calls, we restrict jumping to 32-bits */
 874 #define amd64_call_membase_size(inst,basereg,disp,size)                   \
 875   do {                                                                    \
 876     amd64_codegen_pre((inst));                                            \
 877     amd64_call_sequence_pre(inst);                                        \
 878     amd64_mov_reg_membase((inst), AMD64_R11, (basereg), (disp), 4);       \
 879     amd64_call_reg_internal((inst), AMD64_R11);                           \
 880     amd64_call_sequence_post(inst);                                       \
 881     amd64_codegen_post((inst));                                           \
 882   } while (0)
 883
 884 /* Size is ignored for Native Client jumps, we restrict jumping to 32-bits */
 885 #define amd64_jump_membase_size(inst,basereg,disp,size)                   \
 886   do {                                                                    \
 887     amd64_mov_reg_membase((inst), AMD64_R11, (basereg), (disp), 4);       \
 888     amd64_jump_reg_size((inst), AMD64_R11, 4);                            \
 889   } while (0)
 890
 891 /* On Native Client we can't jump more than INT_MAX in either direction */
 892 #define amd64_jump_code_size(inst,target,size)                            \
 893   do {                                                                    \
 894     /* x86_jump_code used twice in case of */                             \
 895     /* relocation by amd64_codegen_post    */                             \
 896     guint8* jump_start;                                                   \
 897     amd64_codegen_pre(inst);                                              \
 898     assert(amd64_is_imm32 ((gint64)(target) - (gint64)(inst)));           \
 899     x86_jump_code((inst),(target));                                       \
 900     inst = amd64_codegen_post(inst);                                      \
 901     jump_start = (inst);                                                  \
 902     x86_jump_code((inst),(target));                                       \
 903     mono_amd64_patch(jump_start, (target));                               \
 904 } while (0)
 905
 906 #endif /*__native_client_codegen__*/
 907
 908 /*
 909  * SSE
 910  */
 911
 912 //TODO Reorganize SSE opcode defines.
 913
 914 /* Two opcode SSE defines */
 915
 916 #define emit_sse_reg_reg_op2_size(inst,dreg,reg,op1,op2,size) do { \
 917     amd64_codegen_pre(inst); \
 918     amd64_emit_rex ((inst), size, (dreg), 0, (reg)); \
 919     *(inst)++ = (unsigned char)(op1); \
 920     *(inst)++ = (unsigned char)(op2); \
 921     x86_reg_emit ((inst), (dreg), (reg)); \
 922     amd64_codegen_post(inst); \
 923 } while (0)
 924
 925 #define emit_sse_reg_reg_op2(inst,dreg,reg,op1,op2) emit_sse_reg_reg_op2_size ((inst), (dreg), (reg), (op1), (op2), 0)
 926
 927 #define emit_sse_reg_reg_op2_imm(inst,dreg,reg,op1,op2,imm) do { \
 928    amd64_codegen_pre(inst); \
 929    emit_sse_reg_reg_op2 ((inst), (dreg), (reg), (op1), (op2)); \
 930    x86_imm_emit8 ((inst), (imm)); \
 931    amd64_codegen_post(inst); \
 932 } while (0)
 933
 934 #define emit_sse_membase_reg_op2(inst,basereg,disp,reg,op1,op2) do { \
 935     amd64_codegen_pre(inst); \
 936     amd64_emit_rex ((inst), 0, (reg), 0, (basereg)); \
 937     *(inst)++ = (unsigned char)(op1); \
 938     *(inst)++ = (unsigned char)(op2); \
 939     amd64_membase_emit ((inst), (reg), (basereg), (disp)); \
 940     amd64_codegen_post(inst); \
 941 } while (0)
 942
 943 #define emit_sse_reg_membase_op2(inst,dreg,basereg,disp,op1,op2) do { \
 944     amd64_codegen_pre(inst); \
 945     amd64_emit_rex ((inst), 0, (dreg), 0, (basereg) == AMD64_RIP ? 0 : (basereg)); \
 946     *(inst)++ = (unsigned char)(op1); \
 947     *(inst)++ = (unsigned char)(op2); \
 948     amd64_membase_emit ((inst), (dreg), (basereg), (disp)); \
 949     amd64_codegen_post(inst); \
 950 } while (0)
 951
 952 /* Three opcode SSE defines */
 953
 954 #define emit_opcode3(inst,op1,op2,op3) do { \
 955    *(inst)++ = (unsigned char)(op1); \
 956    *(inst)++ = (unsigned char)(op2); \
 957    *(inst)++ = (unsigned char)(op3); \
 958 } while (0)
 959
 960 #define emit_sse_reg_reg_size(inst,dreg,reg,op1,op2,op3,size) do { \
 961     amd64_codegen_pre(inst); \
 962     *(inst)++ = (unsigned char)(op1); \
 963         amd64_emit_rex ((inst), size, (dreg), 0, (reg)); \
 964     *(inst)++ = (unsigned char)(op2); \
 965     *(inst)++ = (unsigned char)(op3); \
 966     x86_reg_emit ((inst), (dreg), (reg)); \
 967     amd64_codegen_post(inst); \
 968 } while (0)
 969
 970 #define emit_sse_reg_reg(inst,dreg,reg,op1,op2,op3) emit_sse_reg_reg_size ((inst), (dreg), (reg), (op1), (op2), (op3), 0)
 971
 972 #define emit_sse_reg_reg_imm(inst,dreg,reg,op1,op2,op3,imm) do { \
 973    amd64_codegen_pre(inst); \
 974    emit_sse_reg_reg ((inst), (dreg), (reg), (op1), (op2), (op3)); \
 975    x86_imm_emit8 ((inst), (imm)); \
 976    amd64_codegen_post(inst); \
 977 } while (0)
 978
 979 #define emit_sse_membase_reg(inst,basereg,disp,reg,op1,op2,op3) do { \
 980     amd64_codegen_pre(inst); \
 981     x86_prefix((inst), (unsigned char)(op1)); \
 982     amd64_emit_rex ((inst), 0, (reg), 0, (basereg)); \
 983     *(inst)++ = (unsigned char)(op2); \
 984     *(inst)++ = (unsigned char)(op3); \
 985     amd64_membase_emit ((inst), (reg), (basereg), (disp)); \
 986     amd64_codegen_post(inst); \
 987 } while (0)
 988
 989 #define emit_sse_reg_membase(inst,dreg,basereg,disp,op1,op2,op3) do { \
 990     amd64_codegen_pre(inst); \
 991     x86_prefix((inst), (unsigned char)(op1)); \
 992     amd64_emit_rex ((inst), 0, (dreg), 0, (basereg) == AMD64_RIP ? 0 : (basereg)); \
 993     *(inst)++ = (unsigned char)(op2); \
 994     *(inst)++ = (unsigned char)(op3); \
 995     amd64_membase_emit ((inst), (dreg), (basereg), (disp)); \
 996     amd64_codegen_post(inst); \
 997 } while (0)
 998
 999 /* Four opcode SSE defines */
1000
1001 #define emit_sse_reg_reg_op4_size(inst,dreg,reg,op1,op2,op3,op4,size) do { \
1002     amd64_codegen_pre(inst); \
1003     x86_prefix((inst), (unsigned char)(op1)); \
1004     amd64_emit_rex ((inst), size, (dreg), 0, (reg)); \
1005     *(inst)++ = (unsigned char)(op2); \
1006     *(inst)++ = (unsigned char)(op3); \
1007     *(inst)++ = (unsigned char)(op4); \
1008     x86_reg_emit ((inst), (dreg), (reg)); \
1009     amd64_codegen_post(inst); \
1010 } while (0)
1011
1012 #define emit_sse_reg_reg_op4(inst,dreg,reg,op1,op2,op3,op4) emit_sse_reg_reg_op4_size ((inst), (dreg), (reg), (op1), (op2), (op3), (op4), 0)
1013
1014 /* specific SSE opcode defines */
1015
1016 #define amd64_sse_xorpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst),(dreg),(reg), 0x66, 0x0f, 0x57)
1017
1018 #define amd64_sse_xorpd_reg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase ((inst),(dreg),(basereg), (disp), 0x66, 0x0f, 0x57)
1019
1020 #define amd64_sse_andpd_reg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase ((inst),(dreg),(basereg), (disp), 0x66, 0x0f, 0x54)
1021
1022 #define amd64_sse_movsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x10)
1023
1024 #define amd64_sse_movsd_reg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase ((inst), (dreg), (basereg), (disp), 0xf2, 0x0f, 0x10)
1025
1026 #define amd64_sse_movsd_membase_reg(inst,basereg,disp,reg) emit_sse_membase_reg ((inst), (basereg), (disp), (reg), 0xf2, 0x0f, 0x11)
1027
1028 #define amd64_sse_movss_membase_reg(inst,basereg,disp,reg) emit_sse_membase_reg ((inst), (basereg), (disp), (reg), 0xf3, 0x0f, 0x11)
1029
1030 #define amd64_sse_movss_reg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase ((inst), (dreg), (basereg), (disp), 0xf3, 0x0f, 0x10)
1031
1032 #define amd64_sse_comisd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst),(dreg),(reg),0x66,0x0f,0x2f)
1033
1034 #define amd64_sse_comisd_reg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase ((inst), (dreg), (basereg), (disp), 0x66, 0x0f, 0x2f)
1035
1036 #define amd64_sse_ucomisd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst),(dreg),(reg),0x66,0x0f,0x2e)
1037
1038 #define amd64_sse_cvtsd2si_reg_reg(inst,dreg,reg) emit_sse_reg_reg_size ((inst), (dreg), (reg), 0xf2, 0x0f, 0x2d, 8)
1039
1040 #define amd64_sse_cvttsd2si_reg_reg_size(inst,dreg,reg,size) emit_sse_reg_reg_size ((inst), (dreg), (reg), 0xf2, 0x0f, 0x2c, (size))
1041
1042 #define amd64_sse_cvttsd2si_reg_reg(inst,dreg,reg) amd64_sse_cvttsd2si_reg_reg_size ((inst), (dreg), (reg), 8)
1043
1044 #define amd64_sse_cvtsi2sd_reg_reg_size(inst,dreg,reg,size) emit_sse_reg_reg_size ((inst), (dreg), (reg), 0xf2, 0x0f, 0x2a, (size))
1045
1046 #define amd64_sse_cvtsi2sd_reg_reg(inst,dreg,reg) amd64_sse_cvtsi2sd_reg_reg_size ((inst), (dreg), (reg), 8)
1047
1048 #define amd64_sse_cvtsd2ss_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x5a)
1049
1050 #define amd64_sse_cvtss2sd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf3, 0x0f, 0x5a)
1051
1052 #define amd64_sse_addsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x58)
1053
1054 #define amd64_sse_subsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x5c)
1055
1056 #define amd64_sse_mulsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x59)
1057
1058 #define amd64_sse_divsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x5e)
1059
1060 #define amd64_sse_sqrtsd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf2, 0x0f, 0x51)
1061
1062
1063 #define amd64_sse_pinsrw_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm ((inst), (dreg), (reg), 0x66, 0x0f, 0xc4, (imm))
1064
1065 #define amd64_sse_pextrw_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm ((inst), (dreg), (reg), 0x66, 0x0f, 0xc5, (imm))
1066
1067
1068 #define amd64_sse_cvttsd2si_reg_xreg_size(inst,reg,xreg,size) emit_sse_reg_reg_size ((inst), (reg), (xreg), 0xf2, 0x0f, 0x2c, (size))
1069
1070
1071 #define amd64_sse_addps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x58)
1072
1073 #define amd64_sse_divps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x5e)
1074
1075 #define amd64_sse_mulps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x59)
1076
1077 #define amd64_sse_subps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x5c)
1078
1079 #define amd64_sse_maxps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x5f)
1080
1081 #define amd64_sse_minps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x5d)
1082
1083 #define amd64_sse_cmpps_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_op2_imm((inst), (dreg), (reg), 0x0f, 0xc2, (imm))
1084
1085 #define amd64_sse_andps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x54)
1086
1087 #define amd64_sse_andnps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x55)
1088
1089 #define amd64_sse_orps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x56)
1090
1091 #define amd64_sse_xorps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x57)
1092
1093 #define amd64_sse_sqrtps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x51)
1094
1095 #define amd64_sse_rsqrtps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x52)
1096
1097 #define amd64_sse_rcpps_reg_reg(inst,dreg,reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x53)
1098
1099 #define amd64_sse_addsubps_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf2, 0x0f, 0xd0)
1100
1101 #define amd64_sse_haddps_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf2, 0x0f, 0x7c)
1102
1103 #define amd64_sse_hsubps_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf2, 0x0f, 0x7d)
1104
1105 #define amd64_sse_movshdup_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf3, 0x0f, 0x16)
1106
1107 #define amd64_sse_movsldup_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf3, 0x0f, 0x12)
1108
1109
1110 #define amd64_sse_pshufhw_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm((inst), (dreg), (reg), 0xf3, 0x0f, 0x70, (imm))
1111
1112 #define amd64_sse_pshuflw_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm((inst), (dreg), (reg), 0xf2, 0x0f, 0x70, (imm))
1113
1114 #define amd64_sse_pshufd_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm((inst), (dreg), (reg), 0x66, 0x0f, 0x70, (imm))
1115
1116
1117 #define amd64_sse_addpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x58)
1118
1119 #define amd64_sse_divpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x5e)
1120
1121 #define amd64_sse_mulpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x59)
1122
1123 #define amd64_sse_subpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x5c)
1124
1125 #define amd64_sse_maxpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x5f)
1126
1127 #define amd64_sse_minpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x5d)
1128
1129 #define amd64_sse_cmppd_reg_reg_imm(inst,dreg,reg,imm) emit_sse_reg_reg_imm((inst), (dreg), (reg), 0x66, 0x0f, 0xc2, (imm))
1130
1131 #define amd64_sse_andpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x54)
1132
1133 #define amd64_sse_andnpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x55)
1134
1135 #define amd64_sse_orpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x56)
1136
1137 #define amd64_sse_sqrtpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x51)
1138
1139 #define amd64_sse_rsqrtpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x52)
1140
1141 #define amd64_sse_rcppd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x53)
1142
1143 #define amd64_sse_addsubpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd0)
1144
1145 #define amd64_sse_haddpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x7c)
1146
1147 #define amd64_sse_hsubpd_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x7d)
1148
1149 #define amd64_sse_movddup_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0xf2, 0x0f, 0x12)
1150
1151
1152 #define amd64_sse_pmovmskb_reg_reg(inst,dreg,reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd7)
1153
1154
1155 #define amd64_sse_pand_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xdb)
1156
1157 #define amd64_sse_por_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xeb)
1158
1159 #define amd64_sse_pxor_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xef)
1160
1161
1162 #define amd64_sse_paddb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xfc)
1163
1164 #define amd64_sse_paddw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xfd)
1165
1166 #define amd64_sse_paddd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xfe)
1167
1168 #define amd64_sse_paddq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd4)
1169
1170
1171 #define amd64_sse_psubb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf8)
1172
1173 #define amd64_sse_psubw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf9)
1174
1175 #define amd64_sse_psubd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xfa)
1176
1177 #define amd64_sse_psubq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xfb)
1178
1179
1180 #define amd64_sse_pmaxub_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xde)
1181
1182 #define amd64_sse_pmaxuw_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3e)
1183
1184 #define amd64_sse_pmaxud_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3f)
1185
1186
1187 #define amd64_sse_pmaxsb_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3c)
1188
1189 #define amd64_sse_pmaxsw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xee)
1190
1191 #define amd64_sse_pmaxsd_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3d)
1192
1193
1194 #define amd64_sse_pavgb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe0)
1195
1196 #define amd64_sse_pavgw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe3)
1197
1198
1199 #define amd64_sse_pminub_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xda)
1200
1201 #define amd64_sse_pminuw_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3a)
1202
1203 #define amd64_sse_pminud_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x3b)
1204
1205
1206 #define amd64_sse_pminsb_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x38)
1207
1208 #define amd64_sse_pminsw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xea)
1209
1210 #define amd64_sse_pminsd_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x39)
1211
1212
1213 #define amd64_sse_pcmpeqb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x74)
1214
1215 #define amd64_sse_pcmpeqw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x75)
1216
1217 #define amd64_sse_pcmpeqd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x76)
1218
1219 #define amd64_sse_pcmpeqq_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x29)
1220
1221
1222 #define amd64_sse_pcmpgtb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x64)
1223
1224 #define amd64_sse_pcmpgtw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x65)
1225
1226 #define amd64_sse_pcmpgtd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x66)
1227
1228 #define amd64_sse_pcmpgtq_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x37)
1229
1230
1231 #define amd64_sse_psadbw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf6)
1232
1233
1234 #define amd64_sse_punpcklbw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x60)
1235
1236 #define amd64_sse_punpcklwd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x61)
1237
1238 #define amd64_sse_punpckldq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x62)
1239
1240 #define amd64_sse_punpcklqdq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x6c)
1241
1242 #define amd64_sse_unpcklpd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x14)
1243
1244 #define amd64_sse_unpcklps_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x14)
1245
1246
1247 #define amd64_sse_punpckhbw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x68)
1248
1249 #define amd64_sse_punpckhwd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x69)
1250
1251 #define amd64_sse_punpckhdq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x6a)
1252
1253 #define amd64_sse_punpckhqdq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x6d)
1254
1255 #define amd64_sse_unpckhpd_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x15)
1256
1257 #define amd64_sse_unpckhps_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x15)
1258
1259
1260 #define amd64_sse_packsswb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x63)
1261
1262 #define amd64_sse_packssdw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x6b)
1263
1264 #define amd64_sse_packuswb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0x67)
1265
1266 #define amd64_sse_packusdw_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x2b)
1267
1268
1269 #define amd64_sse_paddusb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xdc)
1270
1271 #define amd64_sse_psubusb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd8)
1272
1273 #define amd64_sse_paddusw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xdd)
1274
1275 #define amd64_sse_psubusw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd8)
1276
1277
1278 #define amd64_sse_paddsb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xec)
1279
1280 #define amd64_sse_psubsb_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe8)
1281
1282 #define amd64_sse_paddsw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xed)
1283
1284 #define amd64_sse_psubsw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe9)
1285
1286
1287 #define amd64_sse_pmullw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd5)
1288
1289 #define amd64_sse_pmulld_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op4((inst), (dreg), (reg), 0x66, 0x0f, 0x38, 0x40)
1290
1291 #define amd64_sse_pmuludq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf4)
1292
1293 #define amd64_sse_pmulhuw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe4)
1294
1295 #define amd64_sse_pmulhw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe5)
1296
1297
1298 #define amd64_sse_psrlw_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHR, (reg), 0x66, 0x0f, 0x71, (imm))
1299
1300 #define amd64_sse_psrlw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd1)
1301
1302
1303 #define amd64_sse_psraw_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SAR, (reg), 0x66, 0x0f, 0x71, (imm))
1304
1305 #define amd64_sse_psraw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe1)
1306
1307
1308 #define amd64_sse_psllw_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHL, (reg), 0x66, 0x0f, 0x71, (imm))
1309
1310 #define amd64_sse_psllw_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf1)
1311
1312
1313 #define amd64_sse_psrld_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHR, (reg), 0x66, 0x0f, 0x72, (imm))
1314
1315 #define amd64_sse_psrld_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd2)
1316
1317
1318 #define amd64_sse_psrad_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SAR, (reg), 0x66, 0x0f, 0x72, (imm))
1319
1320 #define amd64_sse_psrad_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe2)
1321
1322
1323 #define amd64_sse_pslld_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHL, (reg), 0x66, 0x0f, 0x72, (imm))
1324
1325 #define amd64_sse_pslld_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf2)
1326
1327
1328 #define amd64_sse_psrlq_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHR, (reg), 0x66, 0x0f, 0x73, (imm))
1329
1330 #define amd64_sse_psrlq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xd3)
1331
1332
1333 #define amd64_sse_psraq_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SAR, (reg), 0x66, 0x0f, 0x73, (imm))
1334
1335 #define amd64_sse_psraq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xe3)
1336
1337
1338 #define amd64_sse_psllq_reg_imm(inst, reg, imm) emit_sse_reg_reg_imm((inst), X86_SSE_SHL, (reg), 0x66, 0x0f, 0x73, (imm))
1339
1340 #define amd64_sse_psllq_reg_reg(inst, dreg, reg) emit_sse_reg_reg((inst), (dreg), (reg), 0x66, 0x0f, 0xf3)
1341
1342
1343 #define amd64_movd_xreg_reg_size(inst,dreg,sreg,size) emit_sse_reg_reg_size((inst), (dreg), (sreg), 0x66, 0x0f, 0x6e, (size))
1344
1345 #define amd64_movd_reg_xreg_size(inst,dreg,sreg,size) emit_sse_reg_reg_size((inst), (sreg), (dreg), 0x66, 0x0f, 0x7e, (size))
1346
1347 #define amd64_movd_xreg_membase(inst,dreg,basereg,disp) emit_sse_reg_membase((inst), (dreg), (basereg), (disp), 0x66, 0x0f, 0x6e)
1348
1349
1350 #define amd64_movlhps_reg_reg(inst,dreg,sreg) emit_sse_reg_reg_op2((inst), (dreg), (sreg), 0x0f, 0x16)
1351
1352 #define amd64_movhlps_reg_reg(inst,dreg,sreg) emit_sse_reg_reg_op2((inst), (dreg), (sreg), 0x0f, 0x12)
1353
1354
1355 #define amd64_sse_movups_membase_reg(inst, basereg, disp, reg) emit_sse_membase_reg_op2((inst), (basereg), (disp), (reg), 0x0f, 0x11)
1356
1357 #define amd64_sse_movups_reg_membase(inst, dreg, basereg, disp) emit_sse_reg_membase_op2((inst), (dreg), (basereg), (disp), 0x0f, 0x10)
1358
1359 #define amd64_sse_movaps_membase_reg(inst, basereg, disp, reg) emit_sse_membase_reg_op2((inst), (basereg), (disp), (reg), 0x0f, 0x29)
1360
1361 #define amd64_sse_movaps_reg_membase(inst, dreg, basereg, disp) emit_sse_reg_membase_op2((inst), (dreg), (basereg), (disp), 0x0f, 0x28)
1362
1363 #define amd64_sse_movaps_reg_reg(inst, dreg, reg) emit_sse_reg_reg_op2((inst), (dreg), (reg), 0x0f, 0x28)
1364
1365 #define amd64_sse_movntps_reg_membase(inst, dreg, basereg, disp) emit_sse_reg_membase_op2((inst), (dreg), (basereg), (disp), 0x0f, 0x2b)
1366
1367 #define amd64_sse_prefetch_reg_membase(inst, arg, basereg, disp) emit_sse_reg_membase_op2((inst), (arg), (basereg), (disp), 0x0f, 0x18)
1368
1369 /* Generated from x86-codegen.h */
1370
1371 #define amd64_breakpoint_size(inst,size) do { x86_breakpoint(inst); } while (0)
1372 #define amd64_cld_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_cld(inst); amd64_codegen_post(inst); } while (0)
1373 #define amd64_stosb_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_stosb(inst); amd64_codegen_post(inst); } while (0)
1374 #define amd64_stosl_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_stosl(inst); amd64_codegen_post(inst); } while (0)
1375 #define amd64_stosd_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_stosd(inst); amd64_codegen_post(inst); } while (0)
1376 #define amd64_movsb_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_movsb(inst); amd64_codegen_post(inst); } while (0)
1377 #define amd64_movsl_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_movsl(inst); amd64_codegen_post(inst); } while (0)
1378 #define amd64_movsd_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_movsd(inst); amd64_codegen_post(inst); } while (0)
1379 #define amd64_prefix_size(inst,p,size) do { x86_prefix((inst), p); } while (0)
1380 #define amd64_rdtsc_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_rdtsc(inst); amd64_codegen_post(inst); } while (0)
1381 #define amd64_cmpxchg_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_cmpxchg_reg_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1382 #define amd64_cmpxchg_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_cmpxchg_mem_reg((inst),(mem),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1383 #define amd64_cmpxchg_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_cmpxchg_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1384 #define amd64_xchg_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_xchg_reg_reg((inst),((dreg)&0x7),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1385 #define amd64_xchg_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_xchg_mem_reg((inst),(mem),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1386 #define amd64_xchg_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_xchg_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1387 #define amd64_inc_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_inc_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1388 #define amd64_inc_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_inc_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1389 //#define amd64_inc_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_inc_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1390 #define amd64_dec_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_dec_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1391 #define amd64_dec_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_dec_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1392 //#define amd64_dec_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_dec_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1393 #define amd64_not_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_not_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1394 #define amd64_not_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_not_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1395 #define amd64_not_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_not_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1396 #define amd64_neg_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_neg_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1397 #define amd64_neg_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_neg_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1398 #define amd64_neg_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_neg_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1399 #define amd64_nop_size(inst,size) do { amd64_codegen_pre(inst); x86_nop(inst); amd64_codegen_post(inst); } while (0)
1400 //#define amd64_alu_reg_imm_size(inst,opc,reg,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_alu_reg_imm((inst),(opc),((reg)&0x7),(imm)); amd64_codegen_post(inst); } while (0)
1401 #define amd64_alu_mem_imm_size(inst,opc,mem,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_alu_mem_imm((inst),(opc),(mem),(imm)); amd64_codegen_post(inst); } while (0)
1402 #define amd64_alu_membase_imm_size(inst,opc,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_alu_membase_imm((inst),(opc),((basereg)&0x7),(disp),(imm)); amd64_codegen_post(inst); } while (0)
1403 #define amd64_alu_membase8_imm_size(inst,opc,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_alu_membase8_imm((inst),(opc),((basereg)&0x7),(disp),(imm)); amd64_codegen_post(inst); } while (0)
1404 #define amd64_alu_mem_reg_size(inst,opc,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_alu_mem_reg((inst),(opc),(mem),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1405 #define amd64_alu_membase_reg_size(inst,opc,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_alu_membase_reg((inst),(opc),((basereg)&0x7),(disp),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1406 //#define amd64_alu_reg_reg_size(inst,opc,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_alu_reg_reg((inst),(opc),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1407 #define amd64_alu_reg8_reg8_size(inst,opc,dreg,reg,is_dreg_h,is_reg_h,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_alu_reg8_reg8((inst),(opc),((dreg)&0x7),((reg)&0x7),(is_dreg_h),(is_reg_h)); amd64_codegen_post(inst); } while (0)
1408 #define amd64_alu_reg_mem_size(inst,opc,reg,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_alu_reg_mem((inst),(opc),((reg)&0x7),(mem)); amd64_codegen_post(inst); } while (0)
1409 #define amd64_alu_reg_membase_size(inst,opc,reg,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_alu_reg_membase((inst),(opc),((reg)&0x7),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1410 #define amd64_test_reg_imm_size(inst,reg,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_test_reg_imm((inst),((reg)&0x7),(imm)); amd64_codegen_post(inst); } while (0)
1411 #define amd64_test_mem_imm_size(inst,mem,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_test_mem_imm((inst),(mem),(imm)); amd64_codegen_post(inst); } while (0)
1412 #define amd64_test_membase_imm_size(inst,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_test_membase_imm((inst),((basereg)&0x7),(disp),(imm)); amd64_codegen_post(inst); } while (0)
1413 #define amd64_test_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_test_reg_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1414 #define amd64_test_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_test_mem_reg((inst),(mem),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1415 #define amd64_test_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_test_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1416 #define amd64_shift_reg_imm_size(inst,opc,reg,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_shift_reg_imm((inst),(opc),((reg)&0x7),(imm)); amd64_codegen_post(inst); } while (0)
1417 #define amd64_shift_mem_imm_size(inst,opc,mem,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_shift_mem_imm((inst),(opc),(mem),(imm)); amd64_codegen_post(inst); } while (0)
1418 #define amd64_shift_membase_imm_size(inst,opc,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_shift_membase_imm((inst),(opc),((basereg)&0x7),(disp),(imm)); amd64_codegen_post(inst); } while (0)
1419 #define amd64_shift_reg_size(inst,opc,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_shift_reg((inst),(opc),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1420 #define amd64_shift_mem_size(inst,opc,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_shift_mem((inst),(opc),(mem)); amd64_codegen_post(inst); } while (0)
1421 #define amd64_shift_membase_size(inst,opc,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_shift_membase((inst),(opc),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1422 #define amd64_shrd_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_shrd_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1423 #define amd64_shrd_reg_imm_size(inst,dreg,reg,shamt,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_shrd_reg_imm((inst),((dreg)&0x7),((reg)&0x7),(shamt)); amd64_codegen_post(inst); } while (0)
1424 #define amd64_shld_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_shld_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1425 #define amd64_shld_reg_imm_size(inst,dreg,reg,shamt,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_shld_reg_imm((inst),((dreg)&0x7),((reg)&0x7),(shamt)); amd64_codegen_post(inst); } while (0)
1426 #define amd64_mul_reg_size(inst,reg,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_mul_reg((inst),((reg)&0x7),(is_signed)); amd64_codegen_post(inst); } while (0)
1427 #define amd64_mul_mem_size(inst,mem,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_mul_mem((inst),(mem),(is_signed)); amd64_codegen_post(inst); } while (0)
1428 #define amd64_mul_membase_size(inst,basereg,disp,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_mul_membase((inst),((basereg)&0x7),(disp),(is_signed)); amd64_codegen_post(inst); } while (0)
1429 #define amd64_imul_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_imul_reg_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1430 #define amd64_imul_reg_mem_size(inst,reg,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_imul_reg_mem((inst),((reg)&0x7),(mem)); amd64_codegen_post(inst); } while (0)
1431 #define amd64_imul_reg_membase_size(inst,reg,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_imul_reg_membase((inst),((reg)&0x7),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1432 #define amd64_imul_reg_reg_imm_size(inst,dreg,reg,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_imul_reg_reg_imm((inst),((dreg)&0x7),((reg)&0x7),(imm)); amd64_codegen_post(inst); } while (0)
1433 #define amd64_imul_reg_mem_imm_size(inst,reg,mem,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_imul_reg_mem_imm((inst),((reg)&0x7),(mem),(imm)); amd64_codegen_post(inst); } while (0)
1434 #define amd64_imul_reg_membase_imm_size(inst,reg,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_imul_reg_membase_imm((inst),((reg)&0x7),((basereg)&0x7),(disp),(imm)); amd64_codegen_post(inst); } while (0)
1435 #define amd64_div_reg_size(inst,reg,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_div_reg((inst),((reg)&0x7),(is_signed)); amd64_codegen_post(inst); } while (0)
1436 #define amd64_div_mem_size(inst,mem,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_div_mem((inst),(mem),(is_signed)); amd64_codegen_post(inst); } while (0)
1437 #define amd64_div_membase_size(inst,basereg,disp,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_div_membase((inst),((basereg)&0x7),(disp),(is_signed)); amd64_codegen_post(inst); } while (0)
1438 #define amd64_mov_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_mov_mem_reg((inst),(mem),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1439 //#define amd64_mov_regp_reg_size(inst,regp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(regp),0,(reg)); x86_mov_regp_reg((inst),(regp),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1440 //#define amd64_mov_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_mov_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1441 #define amd64_mov_memindex_reg_size(inst,basereg,disp,indexreg,shift,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),(indexreg),(basereg)); x86_mov_memindex_reg((inst),((basereg)&0x7),(disp),((indexreg)&0x7),(shift),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1442 #define amd64_mov_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_mov_reg_reg((inst),((dreg)&0x7),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1443 //#define amd64_mov_reg_mem_size(inst,reg,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_mov_reg_mem((inst),((reg)&0x7),(mem),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1444 //#define amd64_mov_reg_membase_size(inst,reg,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_mov_reg_membase((inst),((reg)&0x7),((basereg)&0x7),(disp),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1445 //#define amd64_mov_reg_memindex_size(inst,reg,basereg,disp,indexreg,shift,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),(indexreg),(basereg)); x86_mov_reg_memindex((inst),((reg)&0x7),((basereg)&0x7),(disp),((indexreg)&0x7),(shift),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1446 #define amd64_clear_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_clear_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1447 //#define amd64_mov_reg_imm_size(inst,reg,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_mov_reg_imm((inst),((reg)&0x7),(imm)); amd64_codegen_post(inst); } while (0)
1448 #define amd64_mov_mem_imm_size(inst,mem,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_mov_mem_imm((inst),(mem),(imm),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1449 //#define amd64_mov_membase_imm_size(inst,basereg,disp,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_mov_membase_imm((inst),((basereg)&0x7),(disp),(imm),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1450 #define amd64_mov_memindex_imm_size(inst,basereg,disp,indexreg,shift,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,(indexreg),(basereg)); x86_mov_memindex_imm((inst),((basereg)&0x7),(disp),((indexreg)&0x7),(shift),(imm),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0)
1451 #define amd64_lea_mem_size(inst,reg,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_lea_mem((inst),((reg)&0x7),(mem)); amd64_codegen_post(inst); } while (0)
1452 //#define amd64_lea_membase_size(inst,reg,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_lea_membase((inst),((reg)&0x7),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1453 #define amd64_lea_memindex_size(inst,reg,basereg,disp,indexreg,shift,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),(indexreg),(basereg)); x86_lea_memindex((inst),((reg)&0x7),((basereg)&0x7),(disp),((indexreg)&0x7),(shift)); amd64_codegen_post(inst); } while (0)
1454 #define amd64_widen_reg_size(inst,dreg,reg,is_signed,is_half,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_widen_reg((inst),((dreg)&0x7),((reg)&0x7),(is_signed),(is_half)); amd64_codegen_post(inst); } while (0)
1455 #define amd64_widen_mem_size(inst,dreg,mem,is_signed,is_half,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,0); x86_widen_mem((inst),((dreg)&0x7),(mem),(is_signed),(is_half)); amd64_codegen_post(inst); } while (0)
1456 #define amd64_widen_membase_size(inst,dreg,basereg,disp,is_signed,is_half,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(basereg)); x86_widen_membase((inst),((dreg)&0x7),((basereg)&0x7),(disp),(is_signed),(is_half)); amd64_codegen_post(inst); } while (0)
1457 #define amd64_widen_memindex_size(inst,dreg,basereg,disp,indexreg,shift,is_signed,is_half,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),(indexreg),(basereg)); x86_widen_memindex((inst),((dreg)&0x7),((basereg)&0x7),(disp),((indexreg)&0x7),(shift),(is_signed),(is_half)); amd64_codegen_post(inst); } while (0)
1458 #define amd64_cdq_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_cdq(inst); amd64_codegen_post(inst); } while (0)
1459 #define amd64_wait_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_wait(inst); amd64_codegen_post(inst); } while (0)
1460 #define amd64_fp_op_mem_size(inst,opc,mem,is_double,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fp_op_mem((inst),(opc),(mem),(is_double)); amd64_codegen_post(inst); } while (0)
1461 #define amd64_fp_op_membase_size(inst,opc,basereg,disp,is_double,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fp_op_membase((inst),(opc),((basereg)&0x7),(disp),(is_double)); amd64_codegen_post(inst); } while (0)
1462 #define amd64_fp_op_size(inst,opc,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fp_op((inst),(opc),(index)); amd64_codegen_post(inst); } while (0)
1463 #define amd64_fp_op_reg_size(inst,opc,index,pop_stack,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fp_op_reg((inst),(opc),(index),(pop_stack)); amd64_codegen_post(inst); } while (0)
1464 #define amd64_fp_int_op_membase_size(inst,opc,basereg,disp,is_int,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fp_int_op_membase((inst),(opc),((basereg)&0x7),(disp),(is_int)); amd64_codegen_post(inst); } while (0)
1465 #define amd64_fstp_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fstp((inst),(index)); amd64_codegen_post(inst); } while (0)
1466 #define amd64_fcompp_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fcompp(inst); amd64_codegen_post(inst); } while (0)
1467 #define amd64_fucompp_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fucompp(inst); amd64_codegen_post(inst); } while (0)
1468 #define amd64_fnstsw_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fnstsw(inst); amd64_codegen_post(inst); } while (0)
1469 #define amd64_fnstcw_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fnstcw((inst),(mem)); amd64_codegen_post(inst); } while (0)
1470 #define amd64_fnstcw_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_fnstcw_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1471 #define amd64_fldcw_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fldcw((inst),(mem)); amd64_codegen_post(inst); } while (0)
1472 #define amd64_fldcw_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fldcw_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1473 #define amd64_fchs_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fchs(inst); amd64_codegen_post(inst); } while (0)
1474 #define amd64_frem_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_frem(inst); amd64_codegen_post(inst); } while (0)
1475 #define amd64_fxch_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fxch((inst),(index)); amd64_codegen_post(inst); } while (0)
1476 #define amd64_fcomi_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fcomi((inst),(index)); amd64_codegen_post(inst); } while (0)
1477 #define amd64_fcomip_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fcomip((inst),(index)); amd64_codegen_post(inst); } while (0)
1478 #define amd64_fucomi_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fucomi((inst),(index)); amd64_codegen_post(inst); } while (0)
1479 #define amd64_fucomip_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fucomip((inst),(index)); amd64_codegen_post(inst); } while (0)
1480 #define amd64_fld_size(inst,mem,is_double,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fld((inst),(mem),(is_double)); amd64_codegen_post(inst); } while (0)
1481 //#define amd64_fld_membase_size(inst,basereg,disp,is_double,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fld_membase((inst),((basereg)&0x7),(disp),(is_double)); amd64_codegen_post(inst); } while (0)
1482 #define amd64_fld80_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fld80_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1483 #define amd64_fld80_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_fld80_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1484 #define amd64_fild_size(inst,mem,is_long,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fild((inst),(mem),(is_long)); amd64_codegen_post(inst); } while (0)
1485 #define amd64_fild_membase_size(inst,basereg,disp,is_long,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fild_membase((inst),((basereg)&0x7),(disp),(is_long)); amd64_codegen_post(inst); } while (0)
1486 #define amd64_fld_reg_size(inst,index,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fld_reg((inst),(index)); amd64_codegen_post(inst); } while (0)
1487 #define amd64_fldz_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fldz(inst); amd64_codegen_post(inst); } while (0)
1488 #define amd64_fld1_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fld1(inst); amd64_codegen_post(inst); } while (0)
1489 #define amd64_fldpi_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fldpi(inst); amd64_codegen_post(inst); } while (0)
1490 #define amd64_fst_size(inst,mem,is_double,pop_stack,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fst((inst),(mem),(is_double),(pop_stack)); amd64_codegen_post(inst); } while (0)
1491 #define amd64_fst_membase_size(inst,basereg,disp,is_double,pop_stack,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fst_membase((inst),((basereg)&0x7),(disp),(is_double),(pop_stack)); amd64_codegen_post(inst); } while (0)
1492 #define amd64_fst80_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fst80_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1493 #define amd64_fst80_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fst80_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1494 #define amd64_fist_pop_size(inst,mem,is_long,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_fist_pop((inst),(mem),(is_long)); amd64_codegen_post(inst); } while (0)
1495 #define amd64_fist_pop_membase_size(inst,basereg,disp,is_long,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fist_pop_membase((inst),((basereg)&0x7),(disp),(is_long)); amd64_codegen_post(inst); } while (0)
1496 #define amd64_fstsw_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_fstsw(inst); amd64_codegen_post(inst); } while (0)
1497 #define amd64_fist_membase_size(inst,basereg,disp,is_int,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_fist_membase((inst),((basereg)&0x7),(disp),(is_int)); amd64_codegen_post(inst); } while (0)
1498 //#define amd64_push_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_push_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1499 #define amd64_push_regp_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_push_regp((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1500 #define amd64_push_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_push_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1501 //#define amd64_push_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_push_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1502 #define amd64_push_memindex_size(inst,basereg,disp,indexreg,shift,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,(indexreg),(basereg)); x86_push_memindex((inst),((basereg)&0x7),(disp),((indexreg)&0x7),(shift)); amd64_codegen_post(inst); } while (0)
1503 #define amd64_push_imm_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_push_imm((inst),(imm)); amd64_codegen_post(inst); } while (0)
1504 //#define amd64_pop_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_pop_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1505 #define amd64_pop_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_pop_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1506 #define amd64_pop_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_pop_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1507 #define amd64_pushad_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_pushad(inst); amd64_codegen_post(inst); } while (0)
1508 #define amd64_pushfd_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_pushfd(inst); amd64_codegen_post(inst); } while (0)
1509 #define amd64_popad_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_popad(inst); amd64_codegen_post(inst); } while (0)
1510 #define amd64_popfd_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_popfd(inst); amd64_codegen_post(inst); } while (0)
1511 #define amd64_loop_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_loop((inst),(imm)); amd64_codegen_post(inst); } while (0)
1512 #define amd64_loope_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_loope((inst),(imm)); amd64_codegen_post(inst); } while (0)
1513 #define amd64_loopne_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_loopne((inst),(imm)); amd64_codegen_post(inst); } while (0)
1514 #define amd64_jump32_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_jump32((inst),(imm)); amd64_codegen_post(inst); } while (0)
1515 #define amd64_jump8_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_jump8((inst),(imm)); amd64_codegen_post(inst); } while (0)
1516 #if !defined( __native_client_codegen__ )
1517 /* Defined above for Native Client, so they can be used in other macros */
1518 #define amd64_jump_reg_size(inst,reg,size) do { amd64_emit_rex ((inst),0,0,0,(reg)); x86_jump_reg((inst),((reg)&0x7)); } while (0)
1519 #define amd64_jump_mem_size(inst,mem,size) do { amd64_emit_rex ((inst),(size),0,0,0); x86_jump_mem((inst),(mem)); } while (0)
1520 #endif
1521 #define amd64_jump_disp_size(inst,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,0); x86_jump_disp((inst),(disp)); amd64_codegen_post(inst); } while (0)
1522 #define amd64_branch8_size(inst,cond,imm,is_signed,size) do { x86_branch8((inst),(cond),(imm),(is_signed)); } while (0)
1523 #define amd64_branch32_size(inst,cond,imm,is_signed,size) do { x86_branch32((inst),(cond),(imm),(is_signed)); } while (0)
1524 #define amd64_branch_size_body(inst,cond,target,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_branch((inst),(cond),(target),(is_signed)); amd64_codegen_post(inst); } while (0)
1525 #if defined(__default_codegen__)
1526 #define amd64_branch_size(inst,cond,target,is_signed,size) do { amd64_branch_size_body((inst),(cond),(target),(is_signed),(size)); } while (0)
1527 #elif defined(__native_client_codegen__)
1528 #define amd64_branch_size(inst,cond,target,is_signed,size) \
1529         do { \
1530                 /* amd64_branch_size_body used twice in     */ \
1531                 /* case of relocation by amd64_codegen_post */ \
1532                 guint8* branch_start; \
1533                 amd64_codegen_pre(inst); \
1534                 amd64_branch_size_body((inst),(cond),(target),(is_signed),(size)); \
1535                 inst = amd64_codegen_post(inst); \
1536                 branch_start = inst; \
1537                 amd64_branch_size_body((inst),(cond),(target),(is_signed),(size)); \
1538                 mono_amd64_patch(branch_start, (target)); \
1539         } while (0)
1540 #endif
1541
1542 #define amd64_branch_disp_size(inst,cond,disp,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_branch_disp((inst),(cond),(disp),(is_signed)); amd64_codegen_post(inst); } while (0)
1543 #define amd64_set_reg_size(inst,cond,reg,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex((inst),1,0,0,(reg)); x86_set_reg((inst),(cond),((reg)&0x7),(is_signed)); amd64_codegen_post(inst); } while (0)
1544 #define amd64_set_mem_size(inst,cond,mem,is_signed,size) do { amd64_codegen_pre(inst); x86_set_mem((inst),(cond),(mem),(is_signed)); amd64_codegen_post(inst); } while (0)
1545 #define amd64_set_membase_size(inst,cond,basereg,disp,is_signed,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),0,0,0,(basereg)); x86_set_membase((inst),(cond),((basereg)&0x7),(disp),(is_signed)); amd64_codegen_post(inst); } while (0)
1546 //#define amd64_call_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_call_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1547 #define amd64_call_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_call_mem((inst),(mem)); amd64_codegen_post(inst); } while (0)
1548
1549 #if defined(__default_codegen__)
1550
1551 #define amd64_call_imm_size(inst,disp,size) do { x86_call_imm((inst),(disp)); } while (0)
1552 #define amd64_call_code_size(inst,target,size) do { x86_call_code((inst),(target)); } while (0)
1553
1554 #elif defined(__native_client_codegen__)
1555 /* Size is ignored for Native Client calls, we restrict jumping to 32-bits */
1556 #define amd64_call_imm_size(inst,disp,size)             \
1557   do {                                                  \
1558     amd64_codegen_pre((inst));                          \
1559     amd64_call_sequence_pre((inst));                    \
1560     x86_call_imm((inst),(disp));                        \
1561     amd64_call_sequence_post((inst));                   \
1562     amd64_codegen_post((inst));                         \
1563   } while (0)
1564
1565 /* x86_call_code is called twice below, first so we can get the size of the */
1566 /* call sequence, and again so the exact offset from "inst" is used, since  */
1567 /* the sequence could have moved from amd64_call_sequence_post.             */
1568 /* Size is ignored for Native Client jumps, we restrict jumping to 32-bits  */
1569 #define amd64_call_code_size(inst,target,size)          \
1570   do {                                                  \
1571     amd64_codegen_pre((inst));                          \
1572     guint8* adjusted_start;                             \
1573     guint8* call_start;                                 \
1574     amd64_call_sequence_pre((inst));                    \
1575     x86_call_code((inst),(target));                     \
1576     adjusted_start = amd64_call_sequence_post((inst));  \
1577     call_start = adjusted_start;                        \
1578     x86_call_code(adjusted_start, (target));            \
1579     amd64_codegen_post((inst));                         \
1580     mono_amd64_patch(call_start, (target));             \
1581   } while (0)
1582
1583 #endif /*__native_client_codegen__*/
1584
1585 //#define amd64_ret_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_ret(inst); amd64_codegen_post(inst); } while (0)
1586 #define amd64_ret_imm_size(inst,imm,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_ret_imm((inst),(imm)); amd64_codegen_post(inst); } while (0)
1587 #define amd64_cmov_reg_size(inst,cond,is_signed,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_cmov_reg((inst),(cond),(is_signed),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0)
1588 #define amd64_cmov_mem_size(inst,cond,is_signed,reg,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_cmov_mem((inst),(cond),(is_signed),((reg)&0x7),(mem)); amd64_codegen_post(inst); } while (0)
1589 #define amd64_cmov_membase_size(inst,cond,is_signed,reg,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_cmov_membase((inst),(cond),(is_signed),((reg)&0x7),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0)
1590 #define amd64_enter_size(inst,framesize) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_enter((inst),(framesize)); amd64_codegen_post(inst); } while (0)
1591 //#define amd64_leave_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_leave(inst); amd64_codegen_post(inst); } while (0)
1592 #define amd64_sahf_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_sahf(inst); amd64_codegen_post(inst); } while (0)
1593 #define amd64_fsin_size(inst,size) do { amd64_codegen_pre(inst); x86_fsin(inst); amd64_codegen_post(inst); } while (0)
1594 #define amd64_fcos_size(inst,size) do { amd64_codegen_pre(inst); x86_fcos(inst); amd64_codegen_post(inst); } while (0)
1595 #define amd64_fabs_size(inst,size) do { amd64_codegen_pre(inst); x86_fabs(inst); amd64_codegen_post(inst); } while (0)
1596 #define amd64_ftst_size(inst,size) do { amd64_codegen_pre(inst); x86_ftst(inst); amd64_codegen_post(inst); } while (0)
1597 #define amd64_fxam_size(inst,size) do { amd64_codegen_pre(inst); x86_fxam(inst); amd64_codegen_post(inst); } while (0)
1598 #define amd64_fpatan_size(inst,size) do { amd64_codegen_pre(inst); x86_fpatan(inst); amd64_codegen_post(inst); } while (0)
1599 #define amd64_fprem_size(inst,size) do { amd64_codegen_pre(inst); x86_fprem(inst); amd64_codegen_post(inst); } while (0)
1600 #define amd64_fprem1_size(inst,size) do { amd64_codegen_pre(inst); x86_fprem1(inst); amd64_codegen_post(inst); } while (0)
1601 #define amd64_frndint_size(inst,size) do { amd64_codegen_pre(inst); x86_frndint(inst); amd64_codegen_post(inst); } while (0)
1602 #define amd64_fsqrt_size(inst,size) do { amd64_codegen_pre(inst); x86_fsqrt(inst); amd64_codegen_post(inst); } while (0)
1603 #define amd64_fptan_size(inst,size) do { amd64_codegen_pre(inst); x86_fptan(inst); amd64_codegen_post(inst); } while (0)
1604 //#define amd64_padding_size(inst,size) do { amd64_codegen_pre(inst); x86_padding((inst),(size)); amd64_codegen_post(inst); } while (0)
1605 #define amd64_prolog_size(inst,frame_size,reg_mask,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_prolog((inst),(frame_size),(reg_mask)); amd64_codegen_post(inst); } while (0)
1606 #define amd64_epilog_size(inst,reg_mask,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_epilog((inst),(reg_mask)); amd64_codegen_post(inst); } while (0)
1607 #define amd64_xadd_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_xadd_reg_reg ((inst), (dreg), (reg), (size)); amd64_codegen_post(inst); } while (0)
1608 #define amd64_xadd_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_xadd_mem_reg((inst),(mem),((reg)&0x7), (size)); amd64_codegen_post(inst); } while (0)
1609 #define amd64_xadd_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_xadd_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7),(size)); amd64_codegen_post(inst); } while (0)
1610
1611
1612
1613
1614 #define amd64_breakpoint(inst) amd64_breakpoint_size(inst,8)
1615 #define amd64_cld(inst) amd64_cld_size(inst,8)
1616 #define amd64_stosb(inst) amd64_stosb_size(inst,8)
1617 #define amd64_stosl(inst) amd64_stosl_size(inst,8)
1618 #define amd64_stosd(inst) amd64_stosd_size(inst,8)
1619 #define amd64_movsb(inst) amd64_movsb_size(inst,8)
1620 #define amd64_movsl(inst) amd64_movsl_size(inst,8)
1621 #define amd64_movsd(inst) amd64_movsd_size(inst,8)
1622 #define amd64_prefix(inst,p) amd64_prefix_size(inst,p,8)
1623 #define amd64_rdtsc(inst) amd64_rdtsc_size(inst,8)
1624 #define amd64_cmpxchg_reg_reg(inst,dreg,reg) amd64_cmpxchg_reg_reg_size(inst,dreg,reg,8)
1625 #define amd64_cmpxchg_mem_reg(inst,mem,reg) amd64_cmpxchg_mem_reg_size(inst,mem,reg,8)
1626 #define amd64_cmpxchg_membase_reg(inst,basereg,disp,reg) amd64_cmpxchg_membase_reg_size(inst,basereg,disp,reg,8)
1627 #define amd64_xchg_reg_reg(inst,dreg,reg,size) amd64_xchg_reg_reg_size(inst,dreg,reg,size)
1628 #define amd64_xchg_mem_reg(inst,mem,reg,size) amd64_xchg_mem_reg_size(inst,mem,reg,size)
1629 #define amd64_xchg_membase_reg(inst,basereg,disp,reg,size) amd64_xchg_membase_reg_size(inst,basereg,disp,reg,size)
1630 #define amd64_xadd_reg_reg(inst,dreg,reg,size) amd64_xadd_reg_reg_size(inst,dreg,reg,size)
1631 #define amd64_xadd_mem_reg(inst,mem,reg,size) amd64_xadd_mem_reg_size(inst,mem,reg,size)
1632 #define amd64_xadd_membase_reg(inst,basereg,disp,reg,size) amd64_xadd_membase_reg_size(inst,basereg,disp,reg,size)
1633 #define amd64_inc_mem(inst,mem) amd64_inc_mem_size(inst,mem,8)
1634 #define amd64_inc_membase(inst,basereg,disp) amd64_inc_membase_size(inst,basereg,disp,8)
1635 #define amd64_inc_reg(inst,reg) amd64_inc_reg_size(inst,reg,8)
1636 #define amd64_dec_mem(inst,mem) amd64_dec_mem_size(inst,mem,8)
1637 #define amd64_dec_membase(inst,basereg,disp) amd64_dec_membase_size(inst,basereg,disp,8)
1638 #define amd64_dec_reg(inst,reg) amd64_dec_reg_size(inst,reg,8)
1639 #define amd64_not_mem(inst,mem) amd64_not_mem_size(inst,mem,8)
1640 #define amd64_not_membase(inst,basereg,disp) amd64_not_membase_size(inst,basereg,disp,8)
1641 #define amd64_not_reg(inst,reg) amd64_not_reg_size(inst,reg,8)
1642 #define amd64_neg_mem(inst,mem) amd64_neg_mem_size(inst,mem,8)
1643 #define amd64_neg_membase(inst,basereg,disp) amd64_neg_membase_size(inst,basereg,disp,8)
1644 #define amd64_neg_reg(inst,reg) amd64_neg_reg_size(inst,reg,8)
1645 #define amd64_nop(inst) amd64_nop_size(inst,8)
1646 //#define amd64_alu_reg_imm(inst,opc,reg,imm) amd64_alu_reg_imm_size(inst,opc,reg,imm,8)
1647 #define amd64_alu_mem_imm(inst,opc,mem,imm) amd64_alu_mem_imm_size(inst,opc,mem,imm,8)
1648 #define amd64_alu_membase_imm(inst,opc,basereg,disp,imm) amd64_alu_membase_imm_size(inst,opc,basereg,disp,imm,8)
1649 #define amd64_alu_mem_reg(inst,opc,mem,reg) amd64_alu_mem_reg_size(inst,opc,mem,reg,8)
1650 #define amd64_alu_membase_reg(inst,opc,basereg,disp,reg) amd64_alu_membase_reg_size(inst,opc,basereg,disp,reg,8)
1651 //#define amd64_alu_reg_reg(inst,opc,dreg,reg) amd64_alu_reg_reg_size(inst,opc,dreg,reg,8)
1652 #define amd64_alu_reg8_reg8(inst,opc,dreg,reg,is_dreg_h,is_reg_h) amd64_alu_reg8_reg8_size(inst,opc,dreg,reg,is_dreg_h,is_reg_h,8)
1653 #define amd64_alu_reg_mem(inst,opc,reg,mem) amd64_alu_reg_mem_size(inst,opc,reg,mem,8)
1654 #define amd64_alu_reg_membase(inst,opc,reg,basereg,disp) amd64_alu_reg_membase_size(inst,opc,reg,basereg,disp,8)
1655 #define amd64_test_reg_imm(inst,reg,imm) amd64_test_reg_imm_size(inst,reg,imm,8)
1656 #define amd64_test_mem_imm(inst,mem,imm) amd64_test_mem_imm_size(inst,mem,imm,8)
1657 #define amd64_test_membase_imm(inst,basereg,disp,imm) amd64_test_membase_imm_size(inst,basereg,disp,imm,8)
1658 #define amd64_test_reg_reg(inst,dreg,reg) amd64_test_reg_reg_size(inst,dreg,reg,8)
1659 #define amd64_test_mem_reg(inst,mem,reg) amd64_test_mem_reg_size(inst,mem,reg,8)
1660 #define amd64_test_membase_reg(inst,basereg,disp,reg) amd64_test_membase_reg_size(inst,basereg,disp,reg,8)
1661 #define amd64_shift_reg_imm(inst,opc,reg,imm) amd64_shift_reg_imm_size(inst,opc,reg,imm,8)
1662 #define amd64_shift_mem_imm(inst,opc,mem,imm) amd64_shift_mem_imm_size(inst,opc,mem,imm,8)
1663 #define amd64_shift_membase_imm(inst,opc,basereg,disp,imm) amd64_shift_membase_imm_size(inst,opc,basereg,disp,imm,8)
1664 #define amd64_shift_reg(inst,opc,reg) amd64_shift_reg_size(inst,opc,reg,8)
1665 #define amd64_shift_mem(inst,opc,mem) amd64_shift_mem_size(inst,opc,mem,8)
1666 #define amd64_shift_membase(inst,opc,basereg,disp) amd64_shift_membase_size(inst,opc,basereg,disp,8)
1667 #define amd64_shrd_reg(inst,dreg,reg) amd64_shrd_reg_size(inst,dreg,reg,8)
1668 #define amd64_shrd_reg_imm(inst,dreg,reg,shamt) amd64_shrd_reg_imm_size(inst,dreg,reg,shamt,8)
1669 #define amd64_shld_reg(inst,dreg,reg) amd64_shld_reg_size(inst,dreg,reg,8)
1670 #define amd64_shld_reg_imm(inst,dreg,reg,shamt) amd64_shld_reg_imm_size(inst,dreg,reg,shamt,8)
1671 #define amd64_mul_reg(inst,reg,is_signed) amd64_mul_reg_size(inst,reg,is_signed,8)
1672 #define amd64_mul_mem(inst,mem,is_signed) amd64_mul_mem_size(inst,mem,is_signed,8)
1673 #define amd64_mul_membase(inst,basereg,disp,is_signed) amd64_mul_membase_size(inst,basereg,disp,is_signed,8)
1674 #define amd64_imul_reg_reg(inst,dreg,reg) amd64_imul_reg_reg_size(inst,dreg,reg,8)
1675 #define amd64_imul_reg_mem(inst,reg,mem) amd64_imul_reg_mem_size(inst,reg,mem,8)
1676 #define amd64_imul_reg_membase(inst,reg,basereg,disp) amd64_imul_reg_membase_size(inst,reg,basereg,disp,8)
1677 #define amd64_imul_reg_reg_imm(inst,dreg,reg,imm) amd64_imul_reg_reg_imm_size(inst,dreg,reg,imm,8)
1678 #define amd64_imul_reg_mem_imm(inst,reg,mem,imm) amd64_imul_reg_mem_imm_size(inst,reg,mem,imm,8)
1679 #define amd64_imul_reg_membase_imm(inst,reg,basereg,disp,imm) amd64_imul_reg_membase_imm_size(inst,reg,basereg,disp,imm,8)
1680 #define amd64_div_reg(inst,reg,is_signed) amd64_div_reg_size(inst,reg,is_signed,8)
1681 #define amd64_div_mem(inst,mem,is_signed) amd64_div_mem_size(inst,mem,is_signed,8)
1682 #define amd64_div_membase(inst,basereg,disp,is_signed) amd64_div_membase_size(inst,basereg,disp,is_signed,8)
1683 //#define amd64_mov_mem_reg(inst,mem,reg,size) amd64_mov_mem_reg_size(inst,mem,reg,size)
1684 //#define amd64_mov_regp_reg(inst,regp,reg,size) amd64_mov_regp_reg_size(inst,regp,reg,size)
1685 //#define amd64_mov_membase_reg(inst,basereg,disp,reg,size) amd64_mov_membase_reg_size(inst,basereg,disp,reg,size)
1686 #define amd64_mov_memindex_reg(inst,basereg,disp,indexreg,shift,reg,size) amd64_mov_memindex_reg_size(inst,basereg,disp,indexreg,shift,reg,size)
1687 //#define amd64_mov_reg_reg(inst,dreg,reg,size) amd64_mov_reg_reg_size(inst,dreg,reg,size)
1688 //#define amd64_mov_reg_mem(inst,reg,mem,size) amd64_mov_reg_mem_size(inst,reg,mem,size)
1689 //#define amd64_mov_reg_membase(inst,reg,basereg,disp,size) amd64_mov_reg_membase_size(inst,reg,basereg,disp,size)
1690 #define amd64_mov_reg_memindex(inst,reg,basereg,disp,indexreg,shift,size) amd64_mov_reg_memindex_size(inst,reg,basereg,disp,indexreg,shift,size)
1691 #define amd64_clear_reg(inst,reg) amd64_clear_reg_size(inst,reg,8)
1692 //#define amd64_mov_reg_imm(inst,reg,imm) amd64_mov_reg_imm_size(inst,reg,imm,8)
1693 #define amd64_mov_mem_imm(inst,mem,imm,size) amd64_mov_mem_imm_size(inst,mem,imm,size)
1694 //#define amd64_mov_membase_imm(inst,basereg,disp,imm,size) amd64_mov_membase_imm_size(inst,basereg,disp,imm,size)
1695 #define amd64_mov_memindex_imm(inst,basereg,disp,indexreg,shift,imm,size) amd64_mov_memindex_imm_size(inst,basereg,disp,indexreg,shift,imm,size)
1696 #define amd64_lea_mem(inst,reg,mem) amd64_lea_mem_size(inst,reg,mem,8)
1697 //#define amd64_lea_membase(inst,reg,basereg,disp) amd64_lea_membase_size(inst,reg,basereg,disp,8)
1698 #define amd64_lea_memindex(inst,reg,basereg,disp,indexreg,shift) amd64_lea_memindex_size(inst,reg,basereg,disp,indexreg,shift,8)
1699 #define amd64_widen_reg(inst,dreg,reg,is_signed,is_half) amd64_widen_reg_size(inst,dreg,reg,is_signed,is_half,8)
1700 #define amd64_widen_mem(inst,dreg,mem,is_signed,is_half) amd64_widen_mem_size(inst,dreg,mem,is_signed,is_half,8)
1701 #define amd64_widen_membase(inst,dreg,basereg,disp,is_signed,is_half) amd64_widen_membase_size(inst,dreg,basereg,disp,is_signed,is_half,8)
1702 #define amd64_widen_memindex(inst,dreg,basereg,disp,indexreg,shift,is_signed,is_half) amd64_widen_memindex_size(inst,dreg,basereg,disp,indexreg,shift,is_signed,is_half,8)
1703 #define amd64_cdq(inst) amd64_cdq_size(inst,8)
1704 #define amd64_wait(inst) amd64_wait_size(inst,8)
1705 #define amd64_fp_op_mem(inst,opc,mem,is_double) amd64_fp_op_mem_size(inst,opc,mem,is_double,8)
1706 #define amd64_fp_op_membase(inst,opc,basereg,disp,is_double) amd64_fp_op_membase_size(inst,opc,basereg,disp,is_double,8)
1707 #define amd64_fp_op(inst,opc,index) amd64_fp_op_size(inst,opc,index,8)
1708 #define amd64_fp_op_reg(inst,opc,index,pop_stack) amd64_fp_op_reg_size(inst,opc,index,pop_stack,8)
1709 #define amd64_fp_int_op_membase(inst,opc,basereg,disp,is_int) amd64_fp_int_op_membase_size(inst,opc,basereg,disp,is_int,8)
1710 #define amd64_fstp(inst,index) amd64_fstp_size(inst,index,8)
1711 #define amd64_fcompp(inst) amd64_fcompp_size(inst,8)
1712 #define amd64_fucompp(inst) amd64_fucompp_size(inst,8)
1713 #define amd64_fnstsw(inst) amd64_fnstsw_size(inst,8)
1714 #define amd64_fnstcw(inst,mem) amd64_fnstcw_size(inst,mem,8)
1715 #define amd64_fnstcw_membase(inst,basereg,disp) amd64_fnstcw_membase_size(inst,basereg,disp,8)
1716 #define amd64_fldcw(inst,mem) amd64_fldcw_size(inst,mem,8)
1717 #define amd64_fldcw_membase(inst,basereg,disp) amd64_fldcw_membase_size(inst,basereg,disp,8)
1718 #define amd64_fchs(inst) amd64_fchs_size(inst,8)
1719 #define amd64_frem(inst) amd64_frem_size(inst,8)
1720 #define amd64_fxch(inst,index) amd64_fxch_size(inst,index,8)
1721 #define amd64_fcomi(inst,index) amd64_fcomi_size(inst,index,8)
1722 #define amd64_fcomip(inst,index) amd64_fcomip_size(inst,index,8)
1723 #define amd64_fucomi(inst,index) amd64_fucomi_size(inst,index,8)
1724 #define amd64_fucomip(inst,index) amd64_fucomip_size(inst,index,8)
1725 #define amd64_fld(inst,mem,is_double) amd64_fld_size(inst,mem,is_double,8)
1726 #define amd64_fld_membase(inst,basereg,disp,is_double)  amd64_fld_membase_size(inst,basereg,disp,is_double,8)
1727 #define amd64_fld80_mem(inst,mem) amd64_fld80_mem_size(inst,mem,8)
1728 #define amd64_fld80_membase(inst,basereg,disp) amd64_fld80_membase_size(inst,basereg,disp,8)
1729 #define amd64_fild(inst,mem,is_long) amd64_fild_size(inst,mem,is_long,8)
1730 #define amd64_fild_membase(inst,basereg,disp,is_long) amd64_fild_membase_size(inst,basereg,disp,is_long,8)
1731 #define amd64_fld_reg(inst,index) amd64_fld_reg_size(inst,index,8)
1732 #define amd64_fldz(inst) amd64_fldz_size(inst,8)
1733 #define amd64_fld1(inst) amd64_fld1_size(inst,8)
1734 #define amd64_fldpi(inst) amd64_fldpi_size(inst,8)
1735 #define amd64_fst(inst,mem,is_double,pop_stack) amd64_fst_size(inst,mem,is_double,pop_stack,8)
1736 #define amd64_fst_membase(inst,basereg,disp,is_double,pop_stack) amd64_fst_membase_size(inst,basereg,disp,is_double,pop_stack,8)
1737 #define amd64_fst80_mem(inst,mem) amd64_fst80_mem_size(inst,mem,8)
1738 #define amd64_fst80_membase(inst,basereg,disp) amd64_fst80_membase_size(inst,basereg,disp,8)
1739 #define amd64_fist_pop(inst,mem,is_long) amd64_fist_pop_size(inst,mem,is_long,8)
1740 #define amd64_fist_pop_membase(inst,basereg,disp,is_long) amd64_fist_pop_membase_size(inst,basereg,disp,is_long,8)
1741 #define amd64_fstsw(inst) amd64_fstsw_size(inst,8)
1742 #define amd64_fist_membase(inst,basereg,disp,is_int) amd64_fist_membase_size(inst,basereg,disp,is_int,8)
1743 //#define amd64_push_reg(inst,reg) amd64_push_reg_size(inst,reg,8)
1744 #define amd64_push_regp(inst,reg) amd64_push_regp_size(inst,reg,8)
1745 #define amd64_push_mem(inst,mem) amd64_push_mem_size(inst,mem,8)
1746 //#define amd64_push_membase(inst,basereg,disp) amd64_push_membase_size(inst,basereg,disp,8)
1747 #define amd64_push_memindex(inst,basereg,disp,indexreg,shift) amd64_push_memindex_size(inst,basereg,disp,indexreg,shift,8)
1748 #define amd64_push_imm(inst,imm) amd64_push_imm_size(inst,imm,8)
1749 //#define amd64_pop_reg(inst,reg) amd64_pop_reg_size(inst,reg,8)
1750 #define amd64_pop_mem(inst,mem) amd64_pop_mem_size(inst,mem,8)
1751 #define amd64_pop_membase(inst,basereg,disp) amd64_pop_membase_size(inst,basereg,disp,8)
1752 #define amd64_pushad(inst) amd64_pushad_size(inst,8)
1753 #define amd64_pushfd(inst) amd64_pushfd_size(inst,8)
1754 #define amd64_popad(inst) amd64_popad_size(inst,8)
1755 #define amd64_popfd(inst) amd64_popfd_size(inst,8)
1756 #define amd64_loop(inst,imm) amd64_loop_size(inst,imm,8)
1757 #define amd64_loope(inst,imm) amd64_loope_size(inst,imm,8)
1758 #define amd64_loopne(inst,imm) amd64_loopne_size(inst,imm,8)
1759 #define amd64_jump32(inst,imm) amd64_jump32_size(inst,imm,8)
1760 #define amd64_jump8(inst,imm) amd64_jump8_size(inst,imm,8)
1761 #define amd64_jump_reg(inst,reg) amd64_jump_reg_size(inst,reg,8)
1762 #define amd64_jump_mem(inst,mem) amd64_jump_mem_size(inst,mem,8)
1763 #define amd64_jump_membase(inst,basereg,disp) amd64_jump_membase_size(inst,basereg,disp,8)
1764 #define amd64_jump_code(inst,target) amd64_jump_code_size(inst,target,8)
1765 #define amd64_jump_disp(inst,disp) amd64_jump_disp_size(inst,disp,8)
1766 #define amd64_branch8(inst,cond,imm,is_signed) amd64_branch8_size(inst,cond,imm,is_signed,8)
1767 #define amd64_branch32(inst,cond,imm,is_signed) amd64_branch32_size(inst,cond,imm,is_signed,8)
1768 #define amd64_branch(inst,cond,target,is_signed) amd64_branch_size(inst,cond,target,is_signed,8)
1769 #define amd64_branch_disp(inst,cond,disp,is_signed) amd64_branch_disp_size(inst,cond,disp,is_signed,8)
1770 #define amd64_set_reg(inst,cond,reg,is_signed) amd64_set_reg_size(inst,cond,reg,is_signed,8)
1771 #define amd64_set_mem(inst,cond,mem,is_signed) amd64_set_mem_size(inst,cond,mem,is_signed,8)
1772 #define amd64_set_membase(inst,cond,basereg,disp,is_signed) amd64_set_membase_size(inst,cond,basereg,disp,is_signed,8)
1773 #define amd64_call_imm(inst,disp) amd64_call_imm_size(inst,disp,8)
1774 //#define amd64_call_reg(inst,reg) amd64_call_reg_size(inst,reg,8)
1775 #define amd64_call_mem(inst,mem) amd64_call_mem_size(inst,mem,8)
1776 #define amd64_call_membase(inst,basereg,disp) amd64_call_membase_size(inst,basereg,disp,8)
1777 #define amd64_call_code(inst,target) amd64_call_code_size(inst,target,8)
1778 //#define amd64_ret(inst) amd64_ret_size(inst,8)
1779 #define amd64_ret_imm(inst,imm) amd64_ret_imm_size(inst,imm,8)
1780 #define amd64_cmov_reg(inst,cond,is_signed,dreg,reg) amd64_cmov_reg_size(inst,cond,is_signed,dreg,reg,8)
1781 #define amd64_cmov_mem(inst,cond,is_signed,reg,mem) amd64_cmov_mem_size(inst,cond,is_signed,reg,mem,8)
1782 #define amd64_cmov_membase(inst,cond,is_signed,reg,basereg,disp) amd64_cmov_membase_size(inst,cond,is_signed,reg,basereg,disp,8)
1783 #define amd64_enter(inst,framesize) amd64_enter_size(inst,framesize)
1784 //#define amd64_leave(inst) amd64_leave_size(inst,8)
1785 #define amd64_sahf(inst) amd64_sahf_size(inst,8)
1786 #define amd64_fsin(inst) amd64_fsin_size(inst,8)
1787 #define amd64_fcos(inst) amd64_fcos_size(inst,8)
1788 #define amd64_fabs(inst) amd64_fabs_size(inst,8)
1789 #define amd64_ftst(inst) amd64_ftst_size(inst,8)
1790 #define amd64_fxam(inst) amd64_fxam_size(inst,8)
1791 #define amd64_fpatan(inst) amd64_fpatan_size(inst,8)
1792 #define amd64_fprem(inst) amd64_fprem_size(inst,8)
1793 #define amd64_fprem1(inst) amd64_fprem1_size(inst,8)
1794 #define amd64_frndint(inst) amd64_frndint_size(inst,8)
1795 #define amd64_fsqrt(inst) amd64_fsqrt_size(inst,8)
1796 #define amd64_fptan(inst) amd64_fptan_size(inst,8)
1797 #define amd64_padding(inst,size) amd64_padding_size(inst,size)
1798 #define amd64_prolog(inst,frame,reg_mask) amd64_prolog_size(inst,frame,reg_mask,8)
1799 #define amd64_epilog(inst,reg_mask) amd64_epilog_size(inst,reg_mask,8)
1800
1801 #endif // AMD64_H