Source/JavaScriptCore/assembler/X86Assembler.h

   1 /*
   2  * Copyright (C) 2008, 2012-2016 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef X86Assembler_h
  27 #define X86Assembler_h
  28
  29 #if ENABLE(ASSEMBLER) && (CPU(X86) || CPU(X86_64))
  30
  31 #include "AssemblerBuffer.h"
  32 #include "AssemblerCommon.h"
  33 #include "JITCompilationEffort.h"
  34 #include <limits.h>
  35 #include <stdint.h>
  36 #include <wtf/Assertions.h>
  37 #include <wtf/Vector.h>
  38
  39 namespace JSC {
  40
  41 inline bool CAN_SIGN_EXTEND_8_32(int32_t value) { return value == (int32_t)(signed char)value; }
  42
  43 namespace X86Registers {
  44
  45 #define FOR_EACH_CPU_REGISTER(V) \
  46     FOR_EACH_CPU_GPREGISTER(V) \
  47     FOR_EACH_CPU_SPECIAL_REGISTER(V) \
  48     FOR_EACH_CPU_FPREGISTER(V)
  49
  50 // The following are defined as pairs of the following value:
  51 // 1. type of the storage needed to save the register value by the JIT probe.
  52 // 2. name of the register.
  53 #define FOR_EACH_CPU_GPREGISTER(V) \
  54     V(void*, eax) \
  55     V(void*, ecx) \
  56     V(void*, edx) \
  57     V(void*, ebx) \
  58     V(void*, esp) \
  59     V(void*, ebp) \
  60     V(void*, esi) \
  61     V(void*, edi) \
  62     FOR_EACH_X86_64_CPU_GPREGISTER(V)
  63
  64 #define FOR_EACH_CPU_SPECIAL_REGISTER(V) \
  65     V(void*, eip) \
  66     V(void*, eflags) \
  67
  68 // Note: the JITs only stores double values in the FP registers.
  69 #define FOR_EACH_CPU_FPREGISTER(V) \
  70     V(double, xmm0) \
  71     V(double, xmm1) \
  72     V(double, xmm2) \
  73     V(double, xmm3) \
  74     V(double, xmm4) \
  75     V(double, xmm5) \
  76     V(double, xmm6) \
  77     V(double, xmm7) \
  78     FOR_EACH_X86_64_CPU_FPREGISTER(V)
  79
  80 #if CPU(X86)
  81
  82 #define FOR_EACH_X86_64_CPU_GPREGISTER(V) // Nothing to add.
  83 #define FOR_EACH_X86_64_CPU_FPREGISTER(V) // Nothing to add.
  84
  85 #elif CPU(X86_64)
  86
  87 #define FOR_EACH_X86_64_CPU_GPREGISTER(V) \
  88     V(void*, r8) \
  89     V(void*, r9) \
  90     V(void*, r10) \
  91     V(void*, r11) \
  92     V(void*, r12) \
  93     V(void*, r13) \
  94     V(void*, r14) \
  95     V(void*, r15)
  96
  97 #define FOR_EACH_X86_64_CPU_FPREGISTER(V) \
  98     V(double, xmm8) \
  99     V(double, xmm9) \
 100     V(double, xmm10) \
 101     V(double, xmm11) \
 102     V(double, xmm12) \
 103     V(double, xmm13) \
 104     V(double, xmm14) \
 105     V(double, xmm15)
 106
 107 #endif // CPU(X86_64)
 108
 109 typedef enum {
 110     #define DECLARE_REGISTER(_type, _regName) _regName,
 111     FOR_EACH_CPU_GPREGISTER(DECLARE_REGISTER)
 112     #undef DECLARE_REGISTER
 113 } RegisterID;
 114
 115 typedef enum {
 116     #define DECLARE_REGISTER(_type, _regName) _regName,
 117     FOR_EACH_CPU_FPREGISTER(DECLARE_REGISTER)
 118     #undef DECLARE_REGISTER
 119 } XMMRegisterID;
 120
 121 } // namespace X86Register
 122
 123 class X86Assembler {
 124 public:
 125     typedef X86Registers::RegisterID RegisterID;
 126
 127     static constexpr RegisterID firstRegister() { return X86Registers::eax; }
 128     static constexpr RegisterID lastRegister()
 129     {
 130 #if CPU(X86_64)
 131         return X86Registers::r15;
 132 #else
 133         return X86Registers::edi;
 134 #endif
 135     }
 136
 137     typedef X86Registers::XMMRegisterID XMMRegisterID;
 138     typedef XMMRegisterID FPRegisterID;
 139
 140     static constexpr FPRegisterID firstFPRegister() { return X86Registers::xmm0; }
 141     static constexpr FPRegisterID lastFPRegister()
 142     {
 143 #if CPU(X86_64)
 144         return X86Registers::xmm15;
 145 #else
 146         return X86Registers::xmm7;
 147 #endif
 148     }
 149
 150     typedef enum {
 151         ConditionO,
 152         ConditionNO,
 153         ConditionB,
 154         ConditionAE,
 155         ConditionE,
 156         ConditionNE,
 157         ConditionBE,
 158         ConditionA,
 159         ConditionS,
 160         ConditionNS,
 161         ConditionP,
 162         ConditionNP,
 163         ConditionL,
 164         ConditionGE,
 165         ConditionLE,
 166         ConditionG,
 167
 168         ConditionC  = ConditionB,
 169         ConditionNC = ConditionAE,
 170     } Condition;
 171
 172 private:
 173     // OneByteOpcodeID defines the bytecode for 1 byte instruction. It also contains the prefixes
 174     // for two bytes instructions.
 175     // TwoByteOpcodeID, ThreeByteOpcodeID define the opcodes for the multibytes instructions.
 176     //
 177     // The encoding for each instruction can be found in the Intel Architecture Manual in the appendix
 178     // "Opcode Map."
 179     //
 180     // Each opcode can have a suffix describing the type of argument. The full list of suffixes is
 181     // in the "Key to Abbreviations" section of the "Opcode Map".
 182     // The most common argument types are:
 183     //     -E: The argument is either a GPR or a memory address.
 184     //     -G: The argument is a GPR.
 185     //     -I: The argument is an immediate.
 186     // The most common sizes are:
 187     //     -v: 32 or 64bit depending on the operand-size attribute.
 188     //     -z: 32bit in both 32bit and 64bit mode. Common for immediate values.
 189     typedef enum {
 190         OP_ADD_EbGb                     = 0x00,
 191         OP_ADD_EvGv                     = 0x01,
 192         OP_ADD_GvEv                     = 0x03,
 193         OP_ADD_EAXIv                    = 0x05,
 194         OP_OR_EvGv                      = 0x09,
 195         OP_OR_GvEv                      = 0x0B,
 196         OP_OR_EAXIv                     = 0x0D,
 197         OP_2BYTE_ESCAPE                 = 0x0F,
 198         OP_AND_EvGv                     = 0x21,
 199         OP_AND_GvEv                     = 0x23,
 200         OP_SUB_EvGv                     = 0x29,
 201         OP_SUB_GvEv                     = 0x2B,
 202         OP_SUB_EAXIv                    = 0x2D,
 203         PRE_PREDICT_BRANCH_NOT_TAKEN    = 0x2E,
 204         OP_XOR_EvGv                     = 0x31,
 205         OP_XOR_GvEv                     = 0x33,
 206         OP_XOR_EAXIv                    = 0x35,
 207         OP_CMP_EvGv                     = 0x39,
 208         OP_CMP_GvEv                     = 0x3B,
 209         OP_CMP_EAXIv                    = 0x3D,
 210 #if CPU(X86_64)
 211         PRE_REX                         = 0x40,
 212 #endif
 213         OP_PUSH_EAX                     = 0x50,
 214         OP_POP_EAX                      = 0x58,
 215 #if CPU(X86_64)
 216         OP_MOVSXD_GvEv                  = 0x63,
 217 #endif
 218         PRE_OPERAND_SIZE                = 0x66,
 219         PRE_SSE_66                      = 0x66,
 220         OP_PUSH_Iz                      = 0x68,
 221         OP_IMUL_GvEvIz                  = 0x69,
 222         OP_GROUP1_EbIb                  = 0x80,
 223         OP_GROUP1_EvIz                  = 0x81,
 224         OP_GROUP1_EvIb                  = 0x83,
 225         OP_TEST_EbGb                    = 0x84,
 226         OP_TEST_EvGv                    = 0x85,
 227         OP_XCHG_EvGv                    = 0x87,
 228         OP_MOV_EbGb                     = 0x88,
 229         OP_MOV_EvGv                     = 0x89,
 230         OP_MOV_GvEv                     = 0x8B,
 231         OP_LEA                          = 0x8D,
 232         OP_GROUP1A_Ev                   = 0x8F,
 233         OP_NOP                          = 0x90,
 234         OP_XCHG_EAX                     = 0x90,
 235         OP_CDQ                          = 0x99,
 236         OP_MOV_EAXOv                    = 0xA1,
 237         OP_MOV_OvEAX                    = 0xA3,
 238         OP_TEST_ALIb                    = 0xA8,
 239         OP_TEST_EAXIv                   = 0xA9,
 240         OP_MOV_EAXIv                    = 0xB8,
 241         OP_GROUP2_EvIb                  = 0xC1,
 242         OP_RET                          = 0xC3,
 243         OP_GROUP11_EvIb                 = 0xC6,
 244         OP_GROUP11_EvIz                 = 0xC7,
 245         OP_INT3                         = 0xCC,
 246         OP_GROUP2_Ev1                   = 0xD1,
 247         OP_GROUP2_EvCL                  = 0xD3,
 248         OP_ESCAPE_D9                    = 0xD9,
 249         OP_ESCAPE_DD                    = 0xDD,
 250         OP_CALL_rel32                   = 0xE8,
 251         OP_JMP_rel32                    = 0xE9,
 252         PRE_SSE_F2                      = 0xF2,
 253         PRE_SSE_F3                      = 0xF3,
 254         OP_HLT                          = 0xF4,
 255         OP_GROUP3_EbIb                  = 0xF6,
 256         OP_GROUP3_Ev                    = 0xF7,
 257         OP_GROUP3_EvIz                  = 0xF7, // OP_GROUP3_Ev has an immediate, when instruction is a test.
 258         OP_GROUP5_Ev                    = 0xFF,
 259     } OneByteOpcodeID;
 260
 261     typedef enum {
 262         OP2_MOVSD_VsdWsd    = 0x10,
 263         OP2_MOVSD_WsdVsd    = 0x11,
 264         OP2_MOVSS_VsdWsd    = 0x10,
 265         OP2_MOVSS_WsdVsd    = 0x11,
 266         OP2_MOVAPD_VpdWpd   = 0x28,
 267         OP2_MOVAPS_VpdWpd   = 0x28,
 268         OP2_CVTSI2SD_VsdEd  = 0x2A,
 269         OP2_CVTTSD2SI_GdWsd = 0x2C,
 270         OP2_UCOMISD_VsdWsd  = 0x2E,
 271         OP2_3BYTE_ESCAPE_3A = 0x3A,
 272         OP2_CMOVCC          = 0x40,
 273         OP2_ADDSD_VsdWsd    = 0x58,
 274         OP2_MULSD_VsdWsd    = 0x59,
 275         OP2_CVTSD2SS_VsdWsd = 0x5A,
 276         OP2_CVTSS2SD_VsdWsd = 0x5A,
 277         OP2_SUBSD_VsdWsd    = 0x5C,
 278         OP2_DIVSD_VsdWsd    = 0x5E,
 279         OP2_MOVMSKPD_VdEd   = 0x50,
 280         OP2_SQRTSD_VsdWsd   = 0x51,
 281         OP2_ANDPS_VpdWpd    = 0x54,
 282         OP2_ANDNPD_VpdWpd   = 0x55,
 283         OP2_XORPD_VpdWpd    = 0x57,
 284         OP2_MOVD_VdEd       = 0x6E,
 285         OP2_MOVD_EdVd       = 0x7E,
 286         OP2_JCC_rel32       = 0x80,
 287         OP_SETCC            = 0x90,
 288         OP2_3BYTE_ESCAPE_AE = 0xAE,
 289         OP2_IMUL_GvEv       = 0xAF,
 290         OP2_MOVZX_GvEb      = 0xB6,
 291         OP2_BSR             = 0xBD,
 292         OP2_LZCNT           = 0xBD,
 293         OP2_MOVSX_GvEb      = 0xBE,
 294         OP2_MOVZX_GvEw      = 0xB7,
 295         OP2_MOVSX_GvEw      = 0xBF,
 296         OP2_PEXTRW_GdUdIb   = 0xC5,
 297         OP2_PSLLQ_UdqIb     = 0x73,
 298         OP2_PSRLQ_UdqIb     = 0x73,
 299         OP2_POR_VdqWdq      = 0XEB,
 300     } TwoByteOpcodeID;
 301
 302     typedef enum {
 303         OP3_ROUNDSS_VssWssIb = 0x0A,
 304         OP3_ROUNDSD_VsdWsdIb = 0x0B,
 305         OP3_MFENCE           = 0xF0,
 306     } ThreeByteOpcodeID;
 307
 308     struct VexPrefix {
 309         enum : uint8_t {
 310             TwoBytes = 0xC5,
 311             ThreeBytes = 0xC4
 312         };
 313     };
 314     enum class VexImpliedBytes : uint8_t {
 315         TwoBytesOp = 1,
 316         ThreeBytesOp38 = 2,
 317         ThreeBytesOp3A = 3
 318     };
 319
 320     TwoByteOpcodeID cmovcc(Condition cond)
 321     {
 322         return (TwoByteOpcodeID)(OP2_CMOVCC + cond);
 323     }
 324
 325     TwoByteOpcodeID jccRel32(Condition cond)
 326     {
 327         return (TwoByteOpcodeID)(OP2_JCC_rel32 + cond);
 328     }
 329
 330     TwoByteOpcodeID setccOpcode(Condition cond)
 331     {
 332         return (TwoByteOpcodeID)(OP_SETCC + cond);
 333     }
 334
 335     typedef enum {
 336         GROUP1_OP_ADD = 0,
 337         GROUP1_OP_OR  = 1,
 338         GROUP1_OP_ADC = 2,
 339         GROUP1_OP_AND = 4,
 340         GROUP1_OP_SUB = 5,
 341         GROUP1_OP_XOR = 6,
 342         GROUP1_OP_CMP = 7,
 343
 344         GROUP1A_OP_POP = 0,
 345
 346         GROUP2_OP_ROL = 0,
 347         GROUP2_OP_ROR = 1,
 348         GROUP2_OP_RCL = 2,
 349         GROUP2_OP_RCR = 3,
 350
 351         GROUP2_OP_SHL = 4,
 352         GROUP2_OP_SHR = 5,
 353         GROUP2_OP_SAR = 7,
 354
 355         GROUP3_OP_TEST = 0,
 356         GROUP3_OP_NOT  = 2,
 357         GROUP3_OP_NEG  = 3,
 358         GROUP3_OP_DIV = 6,
 359         GROUP3_OP_IDIV = 7,
 360
 361         GROUP5_OP_CALLN = 2,
 362         GROUP5_OP_JMPN  = 4,
 363         GROUP5_OP_PUSH  = 6,
 364
 365         GROUP11_MOV = 0,
 366
 367         GROUP14_OP_PSLLQ = 6,
 368         GROUP14_OP_PSRLQ = 2,
 369
 370         ESCAPE_D9_FSTP_singleReal = 3,
 371         ESCAPE_DD_FSTP_doubleReal = 3,
 372     } GroupOpcodeID;
 373
 374     class X86InstructionFormatter;
 375 public:
 376
 377     X86Assembler()
 378         : m_indexOfLastWatchpoint(INT_MIN)
 379         , m_indexOfTailOfLastWatchpoint(INT_MIN)
 380     {
 381     }
 382
 383     AssemblerBuffer& buffer() { return m_formatter.m_buffer; }
 384
 385     // Stack operations:
 386
 387     void push_r(RegisterID reg)
 388     {
 389         m_formatter.oneByteOp(OP_PUSH_EAX, reg);
 390     }
 391
 392     void pop_r(RegisterID reg)
 393     {
 394         m_formatter.oneByteOp(OP_POP_EAX, reg);
 395     }
 396
 397     void push_i32(int imm)
 398     {
 399         m_formatter.oneByteOp(OP_PUSH_Iz);
 400         m_formatter.immediate32(imm);
 401     }
 402
 403     void push_m(int offset, RegisterID base)
 404     {
 405         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_PUSH, base, offset);
 406     }
 407
 408     void pop_m(int offset, RegisterID base)
 409     {
 410         m_formatter.oneByteOp(OP_GROUP1A_Ev, GROUP1A_OP_POP, base, offset);
 411     }
 412
 413     // Arithmetic operations:
 414
 415 #if !CPU(X86_64)
 416     void adcl_im(int imm, const void* addr)
 417     {
 418         if (CAN_SIGN_EXTEND_8_32(imm)) {
 419             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADC, addr);
 420             m_formatter.immediate8(imm);
 421         } else {
 422             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADC, addr);
 423             m_formatter.immediate32(imm);
 424         }
 425     }
 426 #endif
 427
 428     void addl_rr(RegisterID src, RegisterID dst)
 429     {
 430         m_formatter.oneByteOp(OP_ADD_EvGv, src, dst);
 431     }
 432
 433     void addl_mr(int offset, RegisterID base, RegisterID dst)
 434     {
 435         m_formatter.oneByteOp(OP_ADD_GvEv, dst, base, offset);
 436     }
 437
 438 #if !CPU(X86_64)
 439     void addl_mr(const void* addr, RegisterID dst)
 440     {
 441         m_formatter.oneByteOp(OP_ADD_GvEv, dst, addr);
 442     }
 443 #endif
 444
 445     void addl_rm(RegisterID src, int offset, RegisterID base)
 446     {
 447         m_formatter.oneByteOp(OP_ADD_EvGv, src, base, offset);
 448     }
 449
 450     void addl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
 451     {
 452         m_formatter.oneByteOp(OP_ADD_EvGv, src, base, index, scale, offset);
 453     }
 454
 455     void addb_rm(RegisterID src, int offset, RegisterID base)
 456     {
 457         m_formatter.oneByteOp8(OP_ADD_EbGb, src, base, offset);
 458     }
 459
 460     void addb_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
 461     {
 462         m_formatter.oneByteOp8(OP_ADD_EbGb, src, base, index, scale, offset);
 463     }
 464
 465     void addw_rm(RegisterID src, int offset, RegisterID base)
 466     {
 467         m_formatter.prefix(PRE_OPERAND_SIZE);
 468         m_formatter.oneByteOp8(OP_ADD_EvGv, src, base, offset);
 469     }
 470
 471     void addw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
 472     {
 473         m_formatter.prefix(PRE_OPERAND_SIZE);
 474         m_formatter.oneByteOp8(OP_ADD_EvGv, src, base, index, scale, offset);
 475     }
 476
 477     void addl_ir(int imm, RegisterID dst)
 478     {
 479         if (CAN_SIGN_EXTEND_8_32(imm)) {
 480             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, dst);
 481             m_formatter.immediate8(imm);
 482         } else {
 483             if (dst == X86Registers::eax)
 484                 m_formatter.oneByteOp(OP_ADD_EAXIv);
 485             else
 486                 m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, dst);
 487             m_formatter.immediate32(imm);
 488         }
 489     }
 490
 491     void addl_im(int imm, int offset, RegisterID base)
 492     {
 493         if (CAN_SIGN_EXTEND_8_32(imm)) {
 494             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, offset);
 495             m_formatter.immediate8(imm);
 496         } else {
 497             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, offset);
 498             m_formatter.immediate32(imm);
 499         }
 500     }
 501
 502     void addl_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
 503     {
 504         if (CAN_SIGN_EXTEND_8_32(imm)) {
 505             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, index, scale, offset);
 506             m_formatter.immediate8(imm);
 507         } else {
 508             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, index, scale, offset);
 509             m_formatter.immediate32(imm);
 510         }
 511     }
 512
 513     void addb_im(int imm, int offset, RegisterID base)
 514     {
 515         m_formatter.oneByteOp8(OP_GROUP1_EbIb, GROUP1_OP_ADD, base, offset);
 516         m_formatter.immediate8(imm);
 517     }
 518
 519     void addb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
 520     {
 521         m_formatter.oneByteOp8(OP_GROUP1_EbIb, GROUP1_OP_ADD, base, index, scale, offset);
 522         m_formatter.immediate8(imm);
 523     }
 524
 525     void addw_im(int imm, int offset, RegisterID base)
 526     {
 527         m_formatter.prefix(PRE_OPERAND_SIZE);
 528         if (CAN_SIGN_EXTEND_8_32(imm)) {
 529             m_formatter.oneByteOp8(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, offset);
 530             m_formatter.immediate8(imm);
 531         } else {
 532             m_formatter.oneByteOp8(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, offset);
 533             m_formatter.immediate16(imm);
 534         }
 535     }
 536
 537     void addw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
 538     {
 539         m_formatter.prefix(PRE_OPERAND_SIZE);
 540         if (CAN_SIGN_EXTEND_8_32(imm)) {
 541             m_formatter.oneByteOp8(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, index, scale, offset);
 542             m_formatter.immediate8(imm);
 543         } else {
 544             m_formatter.oneByteOp8(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, index, scale, offset);
 545             m_formatter.immediate16(imm);
 546         }
 547     }
 548
 549 #if CPU(X86_64)
 550     void addq_rr(RegisterID src, RegisterID dst)
 551     {
 552         m_formatter.oneByteOp64(OP_ADD_EvGv, src, dst);
 553     }
 554
 555     void addq_mr(int offset, RegisterID base, RegisterID dst)
 556     {
 557         m_formatter.oneByteOp64(OP_ADD_GvEv, dst, base, offset);
 558     }
 559
 560     void addq_rm(RegisterID src, int offset, RegisterID base)
 561     {
 562         m_formatter.oneByteOp64(OP_ADD_EvGv, src, base, offset);
 563     }
 564
 565     void addq_ir(int imm, RegisterID dst)
 566     {
 567         if (CAN_SIGN_EXTEND_8_32(imm)) {
 568             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_ADD, dst);
 569             m_formatter.immediate8(imm);
 570         } else {
 571             if (dst == X86Registers::eax)
 572                 m_formatter.oneByteOp64(OP_ADD_EAXIv);
 573             else
 574                 m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_ADD, dst);
 575             m_formatter.immediate32(imm);
 576         }
 577     }
 578
 579     void addq_im(int imm, int offset, RegisterID base)
 580     {
 581         if (CAN_SIGN_EXTEND_8_32(imm)) {
 582             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, offset);
 583             m_formatter.immediate8(imm);
 584         } else {
 585             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, offset);
 586             m_formatter.immediate32(imm);
 587         }
 588     }
 589 #else
 590     void addl_im(int imm, const void* addr)
 591     {
 592         if (CAN_SIGN_EXTEND_8_32(imm)) {
 593             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, addr);
 594             m_formatter.immediate8(imm);
 595         } else {
 596             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, addr);
 597             m_formatter.immediate32(imm);
 598         }
 599     }
 600 #endif
 601
 602     void andl_rr(RegisterID src, RegisterID dst)
 603     {
 604         m_formatter.oneByteOp(OP_AND_EvGv, src, dst);
 605     }
 606
 607     void andl_mr(int offset, RegisterID base, RegisterID dst)
 608     {
 609         m_formatter.oneByteOp(OP_AND_GvEv, dst, base, offset);
 610     }
 611
 612     void andl_rm(RegisterID src, int offset, RegisterID base)
 613     {
 614         m_formatter.oneByteOp(OP_AND_EvGv, src, base, offset);
 615     }
 616
 617     void andl_ir(int imm, RegisterID dst)
 618     {
 619         if (CAN_SIGN_EXTEND_8_32(imm)) {
 620             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, dst);
 621             m_formatter.immediate8(imm);
 622         } else {
 623             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, dst);
 624             m_formatter.immediate32(imm);
 625         }
 626     }
 627
 628     void andl_im(int imm, int offset, RegisterID base)
 629     {
 630         if (CAN_SIGN_EXTEND_8_32(imm)) {
 631             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, base, offset);
 632             m_formatter.immediate8(imm);
 633         } else {
 634             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, base, offset);
 635             m_formatter.immediate32(imm);
 636         }
 637     }
 638
 639 #if CPU(X86_64)
 640     void andq_rr(RegisterID src, RegisterID dst)
 641     {
 642         m_formatter.oneByteOp64(OP_AND_EvGv, src, dst);
 643     }
 644
 645     void andq_ir(int imm, RegisterID dst)
 646     {
 647         if (CAN_SIGN_EXTEND_8_32(imm)) {
 648             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_AND, dst);
 649             m_formatter.immediate8(imm);
 650         } else {
 651             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_AND, dst);
 652             m_formatter.immediate32(imm);
 653         }
 654     }
 655 #else
 656     void andl_im(int imm, const void* addr)
 657     {
 658         if (CAN_SIGN_EXTEND_8_32(imm)) {
 659             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, addr);
 660             m_formatter.immediate8(imm);
 661         } else {
 662             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, addr);
 663             m_formatter.immediate32(imm);
 664         }
 665     }
 666 #endif
 667
 668     void dec_r(RegisterID dst)
 669     {
 670         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP1_OP_OR, dst);
 671     }
 672
 673 #if CPU(X86_64)
 674     void decq_r(RegisterID dst)
 675     {
 676         m_formatter.oneByteOp64(OP_GROUP5_Ev, GROUP1_OP_OR, dst);
 677     }
 678 #endif // CPU(X86_64)
 679
 680     void inc_r(RegisterID dst)
 681     {
 682         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP1_OP_ADD, dst);
 683     }
 684
 685 #if CPU(X86_64)
 686     void incq_r(RegisterID dst)
 687     {
 688         m_formatter.oneByteOp64(OP_GROUP5_Ev, GROUP1_OP_ADD, dst);
 689     }
 690
 691     void incq_m(int offset, RegisterID base)
 692     {
 693         m_formatter.oneByteOp64(OP_GROUP5_Ev, GROUP1_OP_ADD, base, offset);
 694     }
 695 #endif // CPU(X86_64)
 696
 697     void negl_r(RegisterID dst)
 698     {
 699         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NEG, dst);
 700     }
 701
 702 #if CPU(X86_64)
 703     void negq_r(RegisterID dst)
 704     {
 705         m_formatter.oneByteOp64(OP_GROUP3_Ev, GROUP3_OP_NEG, dst);
 706     }
 707 #endif
 708
 709     void negl_m(int offset, RegisterID base)
 710     {
 711         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NEG, base, offset);
 712     }
 713
 714     void notl_r(RegisterID dst)
 715     {
 716         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NOT, dst);
 717     }
 718
 719     void notl_m(int offset, RegisterID base)
 720     {
 721         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NOT, base, offset);
 722     }
 723
 724 #if CPU(X86_64)
 725     void notq_r(RegisterID dst)
 726     {
 727         m_formatter.oneByteOp64(OP_GROUP3_Ev, GROUP3_OP_NOT, dst);
 728     }
 729
 730     void notq_m(int offset, RegisterID base)
 731     {
 732         m_formatter.oneByteOp64(OP_GROUP3_Ev, GROUP3_OP_NOT, base, offset);
 733     }
 734 #endif
 735
 736     void orl_rr(RegisterID src, RegisterID dst)
 737     {
 738         m_formatter.oneByteOp(OP_OR_EvGv, src, dst);
 739     }
 740
 741     void orl_mr(int offset, RegisterID base, RegisterID dst)
 742     {
 743         m_formatter.oneByteOp(OP_OR_GvEv, dst, base, offset);
 744     }
 745
 746     void orl_rm(RegisterID src, int offset, RegisterID base)
 747     {
 748         m_formatter.oneByteOp(OP_OR_EvGv, src, base, offset);
 749     }
 750
 751     void orl_ir(int imm, RegisterID dst)
 752     {
 753         if (CAN_SIGN_EXTEND_8_32(imm)) {
 754             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, dst);
 755             m_formatter.immediate8(imm);
 756         } else {
 757             if (dst == X86Registers::eax)
 758                 m_formatter.oneByteOp(OP_OR_EAXIv);
 759             else
 760                 m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, dst);
 761             m_formatter.immediate32(imm);
 762         }
 763     }
 764
 765     void orl_im(int imm, int offset, RegisterID base)
 766     {
 767         if (CAN_SIGN_EXTEND_8_32(imm)) {
 768             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, base, offset);
 769             m_formatter.immediate8(imm);
 770         } else {
 771             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, base, offset);
 772             m_formatter.immediate32(imm);
 773         }
 774     }
 775
 776 #if CPU(X86_64)
 777     void orq_rr(RegisterID src, RegisterID dst)
 778     {
 779         m_formatter.oneByteOp64(OP_OR_EvGv, src, dst);
 780     }
 781
 782     void orq_ir(int imm, RegisterID dst)
 783     {
 784         if (CAN_SIGN_EXTEND_8_32(imm)) {
 785             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_OR, dst);
 786             m_formatter.immediate8(imm);
 787         } else {
 788             if (dst == X86Registers::eax)
 789                 m_formatter.oneByteOp64(OP_OR_EAXIv);
 790             else
 791                 m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_OR, dst);
 792             m_formatter.immediate32(imm);
 793         }
 794     }
 795 #else
 796     void orl_im(int imm, const void* addr)
 797     {
 798         if (CAN_SIGN_EXTEND_8_32(imm)) {
 799             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, addr);
 800             m_formatter.immediate8(imm);
 801         } else {
 802             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, addr);
 803             m_formatter.immediate32(imm);
 804         }
 805     }
 806
 807     void orl_rm(RegisterID src, const void* addr)
 808     {
 809         m_formatter.oneByteOp(OP_OR_EvGv, src, addr);
 810     }
 811 #endif
 812
 813     void subl_rr(RegisterID src, RegisterID dst)
 814     {
 815         m_formatter.oneByteOp(OP_SUB_EvGv, src, dst);
 816     }
 817
 818     void subl_mr(int offset, RegisterID base, RegisterID dst)
 819     {
 820         m_formatter.oneByteOp(OP_SUB_GvEv, dst, base, offset);
 821     }
 822
 823     void subl_rm(RegisterID src, int offset, RegisterID base)
 824     {
 825         m_formatter.oneByteOp(OP_SUB_EvGv, src, base, offset);
 826     }
 827
 828     void subl_ir(int imm, RegisterID dst)
 829     {
 830         if (CAN_SIGN_EXTEND_8_32(imm)) {
 831             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, dst);
 832             m_formatter.immediate8(imm);
 833         } else {
 834             if (dst == X86Registers::eax)
 835                 m_formatter.oneByteOp(OP_SUB_EAXIv);
 836             else
 837                 m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, dst);
 838             m_formatter.immediate32(imm);
 839         }
 840     }
 841
 842     void subl_im(int imm, int offset, RegisterID base)
 843     {
 844         if (CAN_SIGN_EXTEND_8_32(imm)) {
 845             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, base, offset);
 846             m_formatter.immediate8(imm);
 847         } else {
 848             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, base, offset);
 849             m_formatter.immediate32(imm);
 850         }
 851     }
 852
 853 #if CPU(X86_64)
 854     void subq_rr(RegisterID src, RegisterID dst)
 855     {
 856         m_formatter.oneByteOp64(OP_SUB_EvGv, src, dst);
 857     }
 858
 859     void subq_mr(int offset, RegisterID base, RegisterID dst)
 860     {
 861         m_formatter.oneByteOp64(OP_SUB_GvEv, dst, base, offset);
 862     }
 863
 864     void subq_rm(RegisterID src, int offset, RegisterID base)
 865     {
 866         m_formatter.oneByteOp64(OP_SUB_EvGv, src, base, offset);
 867     }
 868
 869     void subq_ir(int imm, RegisterID dst)
 870     {
 871         if (CAN_SIGN_EXTEND_8_32(imm)) {
 872             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_SUB, dst);
 873             m_formatter.immediate8(imm);
 874         } else {
 875             if (dst == X86Registers::eax)
 876                 m_formatter.oneByteOp64(OP_SUB_EAXIv);
 877             else
 878                 m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_SUB, dst);
 879             m_formatter.immediate32(imm);
 880         }
 881     }
 882
 883     void subq_im(int imm, int offset, RegisterID base)
 884     {
 885         if (CAN_SIGN_EXTEND_8_32(imm)) {
 886             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_SUB, base, offset);
 887             m_formatter.immediate8(imm);
 888         } else {
 889             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_SUB, base, offset);
 890             m_formatter.immediate32(imm);
 891         }
 892     }
 893 #else
 894     void subl_im(int imm, const void* addr)
 895     {
 896         if (CAN_SIGN_EXTEND_8_32(imm)) {
 897             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, addr);
 898             m_formatter.immediate8(imm);
 899         } else {
 900             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, addr);
 901             m_formatter.immediate32(imm);
 902         }
 903     }
 904 #endif
 905
 906     void xorl_rr(RegisterID src, RegisterID dst)
 907     {
 908         m_formatter.oneByteOp(OP_XOR_EvGv, src, dst);
 909     }
 910
 911     void xorl_mr(int offset, RegisterID base, RegisterID dst)
 912     {
 913         m_formatter.oneByteOp(OP_XOR_GvEv, dst, base, offset);
 914     }
 915
 916     void xorl_rm(RegisterID src, int offset, RegisterID base)
 917     {
 918         m_formatter.oneByteOp(OP_XOR_EvGv, src, base, offset);
 919     }
 920
 921     void xorl_im(int imm, int offset, RegisterID base)
 922     {
 923         if (CAN_SIGN_EXTEND_8_32(imm)) {
 924             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_XOR, base, offset);
 925             m_formatter.immediate8(imm);
 926         } else {
 927             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_XOR, base, offset);
 928             m_formatter.immediate32(imm);
 929         }
 930     }
 931
 932     void xorl_ir(int imm, RegisterID dst)
 933     {
 934         if (CAN_SIGN_EXTEND_8_32(imm)) {
 935             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_XOR, dst);
 936             m_formatter.immediate8(imm);
 937         } else {
 938             if (dst == X86Registers::eax)
 939                 m_formatter.oneByteOp(OP_XOR_EAXIv);
 940             else
 941                 m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_XOR, dst);
 942             m_formatter.immediate32(imm);
 943         }
 944     }
 945
 946 #if CPU(X86_64)
 947     void xorq_rr(RegisterID src, RegisterID dst)
 948     {
 949         m_formatter.oneByteOp64(OP_XOR_EvGv, src, dst);
 950     }
 951
 952     void xorq_ir(int imm, RegisterID dst)
 953     {
 954         if (CAN_SIGN_EXTEND_8_32(imm)) {
 955             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_XOR, dst);
 956             m_formatter.immediate8(imm);
 957         } else {
 958             if (dst == X86Registers::eax)
 959                 m_formatter.oneByteOp64(OP_XOR_EAXIv);
 960             else
 961                 m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_XOR, dst);
 962             m_formatter.immediate32(imm);
 963         }
 964     }
 965
 966     void xorq_rm(RegisterID src, int offset, RegisterID base)
 967     {
 968         m_formatter.oneByteOp64(OP_XOR_EvGv, src, base, offset);
 969     }
 970
 971     void rorq_i8r(int imm, RegisterID dst)
 972     {
 973         if (imm == 1)
 974             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_ROR, dst);
 975         else {
 976             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_ROR, dst);
 977             m_formatter.immediate8(imm);
 978         }
 979     }
 980
 981 #endif
 982
 983     void lzcnt_rr(RegisterID src, RegisterID dst)
 984     {
 985         m_formatter.prefix(PRE_SSE_F3);
 986         m_formatter.twoByteOp(OP2_LZCNT, dst, src);
 987     }
 988
 989     void lzcnt_mr(int offset, RegisterID base, RegisterID dst)
 990     {
 991         m_formatter.prefix(PRE_SSE_F3);
 992         m_formatter.twoByteOp(OP2_LZCNT, dst, base, offset);
 993     }
 994
 995 #if CPU(X86_64)
 996     void lzcntq_rr(RegisterID src, RegisterID dst)
 997     {
 998         m_formatter.prefix(PRE_SSE_F3);
 999         m_formatter.twoByteOp64(OP2_LZCNT, dst, src);
1000     }
1001
1002     void lzcntq_mr(int offset, RegisterID base, RegisterID dst)
1003     {
1004         m_formatter.prefix(PRE_SSE_F3);
1005         m_formatter.twoByteOp64(OP2_LZCNT, dst, base, offset);
1006     }
1007 #endif
1008
1009     void bsr_rr(RegisterID src, RegisterID dst)
1010     {
1011         m_formatter.twoByteOp(OP2_BSR, dst, src);
1012     }
1013
1014     void bsr_mr(int offset, RegisterID base, RegisterID dst)
1015     {
1016         m_formatter.twoByteOp(OP2_BSR, dst, base, offset);
1017     }
1018
1019 #if CPU(X86_64)
1020     void bsrq_rr(RegisterID src, RegisterID dst)
1021     {
1022         m_formatter.twoByteOp64(OP2_BSR, dst, src);
1023     }
1024
1025     void bsrq_mr(int offset, RegisterID base, RegisterID dst)
1026     {
1027         m_formatter.twoByteOp64(OP2_BSR, dst, base, offset);
1028     }
1029 #endif
1030
1031     void sarl_i8r(int imm, RegisterID dst)
1032     {
1033         if (imm == 1)
1034             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SAR, dst);
1035         else {
1036             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SAR, dst);
1037             m_formatter.immediate8(imm);
1038         }
1039     }
1040
1041     void sarl_CLr(RegisterID dst)
1042     {
1043         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SAR, dst);
1044     }
1045
1046     void shrl_i8r(int imm, RegisterID dst)
1047     {
1048         if (imm == 1)
1049             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SHR, dst);
1050         else {
1051             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SHR, dst);
1052             m_formatter.immediate8(imm);
1053         }
1054     }
1055
1056     void shrl_CLr(RegisterID dst)
1057     {
1058         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SHR, dst);
1059     }
1060
1061     void shll_i8r(int imm, RegisterID dst)
1062     {
1063         if (imm == 1)
1064             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SHL, dst);
1065         else {
1066             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SHL, dst);
1067             m_formatter.immediate8(imm);
1068         }
1069     }
1070
1071     void shll_CLr(RegisterID dst)
1072     {
1073         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SHL, dst);
1074     }
1075
1076 #if CPU(X86_64)
1077     void sarq_CLr(RegisterID dst)
1078     {
1079         m_formatter.oneByteOp64(OP_GROUP2_EvCL, GROUP2_OP_SAR, dst);
1080     }
1081
1082     void sarq_i8r(int imm, RegisterID dst)
1083     {
1084         if (imm == 1)
1085             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_SAR, dst);
1086         else {
1087             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_SAR, dst);
1088             m_formatter.immediate8(imm);
1089         }
1090     }
1091
1092     void shrq_i8r(int imm, RegisterID dst)
1093     {
1094         if (imm == 1)
1095             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_SHR, dst);
1096         else {
1097             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_SHR, dst);
1098             m_formatter.immediate8(imm);
1099         }
1100     }
1101
1102     void shrq_CLr(RegisterID dst)
1103     {
1104         m_formatter.oneByteOp64(OP_GROUP2_EvCL, GROUP2_OP_SHR, dst);
1105     }
1106
1107     void shlq_i8r(int imm, RegisterID dst)
1108     {
1109         if (imm == 1)
1110             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_SHL, dst);
1111         else {
1112             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_SHL, dst);
1113             m_formatter.immediate8(imm);
1114         }
1115     }
1116
1117     void shlq_CLr(RegisterID dst)
1118     {
1119         m_formatter.oneByteOp64(OP_GROUP2_EvCL, GROUP2_OP_SHL, dst);
1120     }
1121 #endif // CPU(X86_64)
1122
1123     void imull_rr(RegisterID src, RegisterID dst)
1124     {
1125         m_formatter.twoByteOp(OP2_IMUL_GvEv, dst, src);
1126     }
1127
1128 #if CPU(X86_64)
1129     void imulq_rr(RegisterID src, RegisterID dst)
1130     {
1131         m_formatter.twoByteOp64(OP2_IMUL_GvEv, dst, src);
1132     }
1133 #endif // CPU(X86_64)
1134
1135     void imull_mr(int offset, RegisterID base, RegisterID dst)
1136     {
1137         m_formatter.twoByteOp(OP2_IMUL_GvEv, dst, base, offset);
1138     }
1139
1140     void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
1141     {
1142         m_formatter.oneByteOp(OP_IMUL_GvEvIz, dst, src);
1143         m_formatter.immediate32(value);
1144     }
1145
1146     void divl_r(RegisterID dst)
1147     {
1148         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_DIV, dst);
1149     }
1150
1151     void idivl_r(RegisterID dst)
1152     {
1153         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_IDIV, dst);
1154     }
1155
1156 #if CPU(X86_64)
1157     void idivq_r(RegisterID dst)
1158     {
1159         m_formatter.oneByteOp64(OP_GROUP3_Ev, GROUP3_OP_IDIV, dst);
1160     }
1161 #endif // CPU(X86_64)
1162
1163     // Comparisons:
1164
1165     void cmpl_rr(RegisterID src, RegisterID dst)
1166     {
1167         m_formatter.oneByteOp(OP_CMP_EvGv, src, dst);
1168     }
1169
1170     void cmpl_rm(RegisterID src, int offset, RegisterID base)
1171     {
1172         m_formatter.oneByteOp(OP_CMP_EvGv, src, base, offset);
1173     }
1174
1175     void cmpl_mr(int offset, RegisterID base, RegisterID src)
1176     {
1177         m_formatter.oneByteOp(OP_CMP_GvEv, src, base, offset);
1178     }
1179
1180     void cmpl_ir(int imm, RegisterID dst)
1181     {
1182         if (CAN_SIGN_EXTEND_8_32(imm)) {
1183             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
1184             m_formatter.immediate8(imm);
1185         } else {
1186             if (dst == X86Registers::eax)
1187                 m_formatter.oneByteOp(OP_CMP_EAXIv);
1188             else
1189                 m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1190             m_formatter.immediate32(imm);
1191         }
1192     }
1193
1194     void cmpl_ir_force32(int imm, RegisterID dst)
1195     {
1196         m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1197         m_formatter.immediate32(imm);
1198     }
1199
1200     void cmpl_im(int imm, int offset, RegisterID base)
1201     {
1202         if (CAN_SIGN_EXTEND_8_32(imm)) {
1203             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, offset);
1204             m_formatter.immediate8(imm);
1205         } else {
1206             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
1207             m_formatter.immediate32(imm);
1208         }
1209     }
1210
1211     void cmpb_im(int imm, int offset, RegisterID base)
1212     {
1213         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, base, offset);
1214         m_formatter.immediate8(imm);
1215     }
1216
1217     void cmpb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1218     {
1219         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, base, index, scale, offset);
1220         m_formatter.immediate8(imm);
1221     }
1222
1223 #if CPU(X86)
1224     void cmpb_im(int imm, const void* addr)
1225     {
1226         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, addr);
1227         m_formatter.immediate8(imm);
1228     }
1229 #endif
1230
1231     void cmpl_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1232     {
1233         if (CAN_SIGN_EXTEND_8_32(imm)) {
1234             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
1235             m_formatter.immediate8(imm);
1236         } else {
1237             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
1238             m_formatter.immediate32(imm);
1239         }
1240     }
1241
1242     void cmpl_im_force32(int imm, int offset, RegisterID base)
1243     {
1244         m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
1245         m_formatter.immediate32(imm);
1246     }
1247
1248 #if CPU(X86_64)
1249     void cmpq_rr(RegisterID src, RegisterID dst)
1250     {
1251         m_formatter.oneByteOp64(OP_CMP_EvGv, src, dst);
1252     }
1253
1254     void cmpq_rm(RegisterID src, int offset, RegisterID base)
1255     {
1256         m_formatter.oneByteOp64(OP_CMP_EvGv, src, base, offset);
1257     }
1258
1259     void cmpq_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1260     {
1261         m_formatter.oneByteOp64(OP_CMP_EvGv, src, base, index, scale, offset);
1262     }
1263
1264     void cmpq_mr(int offset, RegisterID base, RegisterID src)
1265     {
1266         m_formatter.oneByteOp64(OP_CMP_GvEv, src, base, offset);
1267     }
1268
1269     void cmpq_ir(int imm, RegisterID dst)
1270     {
1271         if (CAN_SIGN_EXTEND_8_32(imm)) {
1272             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
1273             m_formatter.immediate8(imm);
1274         } else {
1275             if (dst == X86Registers::eax)
1276                 m_formatter.oneByteOp64(OP_CMP_EAXIv);
1277             else
1278                 m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1279             m_formatter.immediate32(imm);
1280         }
1281     }
1282
1283     void cmpq_im(int imm, int offset, RegisterID base)
1284     {
1285         if (CAN_SIGN_EXTEND_8_32(imm)) {
1286             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, offset);
1287             m_formatter.immediate8(imm);
1288         } else {
1289             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
1290             m_formatter.immediate32(imm);
1291         }
1292     }
1293
1294     void cmpq_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1295     {
1296         if (CAN_SIGN_EXTEND_8_32(imm)) {
1297             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
1298             m_formatter.immediate8(imm);
1299         } else {
1300             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
1301             m_formatter.immediate32(imm);
1302         }
1303     }
1304 #else
1305     void cmpl_rm(RegisterID reg, const void* addr)
1306     {
1307         m_formatter.oneByteOp(OP_CMP_EvGv, reg, addr);
1308     }
1309
1310     void cmpl_im(int imm, const void* addr)
1311     {
1312         if (CAN_SIGN_EXTEND_8_32(imm)) {
1313             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, addr);
1314             m_formatter.immediate8(imm);
1315         } else {
1316             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, addr);
1317             m_formatter.immediate32(imm);
1318         }
1319     }
1320 #endif
1321
1322     void cmpw_ir(int imm, RegisterID dst)
1323     {
1324         if (CAN_SIGN_EXTEND_8_32(imm)) {
1325             m_formatter.prefix(PRE_OPERAND_SIZE);
1326             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
1327             m_formatter.immediate8(imm);
1328         } else {
1329             m_formatter.prefix(PRE_OPERAND_SIZE);
1330             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1331             m_formatter.immediate16(imm);
1332         }
1333     }
1334
1335     void cmpw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1336     {
1337         m_formatter.prefix(PRE_OPERAND_SIZE);
1338         m_formatter.oneByteOp(OP_CMP_EvGv, src, base, index, scale, offset);
1339     }
1340
1341     void cmpw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1342     {
1343         if (CAN_SIGN_EXTEND_8_32(imm)) {
1344             m_formatter.prefix(PRE_OPERAND_SIZE);
1345             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
1346             m_formatter.immediate8(imm);
1347         } else {
1348             m_formatter.prefix(PRE_OPERAND_SIZE);
1349             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
1350             m_formatter.immediate16(imm);
1351         }
1352     }
1353
1354     void testl_rr(RegisterID src, RegisterID dst)
1355     {
1356         m_formatter.oneByteOp(OP_TEST_EvGv, src, dst);
1357     }
1358
1359     void testl_i32r(int imm, RegisterID dst)
1360     {
1361         if (dst == X86Registers::eax)
1362             m_formatter.oneByteOp(OP_TEST_EAXIv);
1363         else
1364             m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, dst);
1365         m_formatter.immediate32(imm);
1366     }
1367
1368     void testl_i32m(int imm, int offset, RegisterID base)
1369     {
1370         m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, offset);
1371         m_formatter.immediate32(imm);
1372     }
1373
1374     void testb_rr(RegisterID src, RegisterID dst)
1375     {
1376         m_formatter.oneByteOp8(OP_TEST_EbGb, src, dst);
1377     }
1378
1379     void testb_im(int imm, int offset, RegisterID base)
1380     {
1381         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, base, offset);
1382         m_formatter.immediate8(imm);
1383     }
1384
1385     void testb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1386     {
1387         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, base, index, scale, offset);
1388         m_formatter.immediate8(imm);
1389     }
1390
1391 #if CPU(X86)
1392     void testb_im(int imm, const void* addr)
1393     {
1394         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, addr);
1395         m_formatter.immediate8(imm);
1396     }
1397 #endif
1398
1399     void testl_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1400     {
1401         m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, index, scale, offset);
1402         m_formatter.immediate32(imm);
1403     }
1404
1405 #if CPU(X86_64)
1406     void testq_rr(RegisterID src, RegisterID dst)
1407     {
1408         m_formatter.oneByteOp64(OP_TEST_EvGv, src, dst);
1409     }
1410
1411     void testq_rm(RegisterID src, int offset, RegisterID base)
1412     {
1413         m_formatter.oneByteOp64(OP_TEST_EvGv, src, base, offset);
1414     }
1415
1416     void testq_i32r(int imm, RegisterID dst)
1417     {
1418         if (dst == X86Registers::eax)
1419             m_formatter.oneByteOp64(OP_TEST_EAXIv);
1420         else
1421             m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, dst);
1422         m_formatter.immediate32(imm);
1423     }
1424
1425     void testq_i32m(int imm, int offset, RegisterID base)
1426     {
1427         m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, offset);
1428         m_formatter.immediate32(imm);
1429     }
1430
1431     void testq_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1432     {
1433         m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, index, scale, offset);
1434         m_formatter.immediate32(imm);
1435     }
1436 #endif
1437
1438     void testw_rr(RegisterID src, RegisterID dst)
1439     {
1440         m_formatter.prefix(PRE_OPERAND_SIZE);
1441         m_formatter.oneByteOp(OP_TEST_EvGv, src, dst);
1442     }
1443
1444     void testb_i8r(int imm, RegisterID dst)
1445     {
1446         if (dst == X86Registers::eax)
1447             m_formatter.oneByteOp(OP_TEST_ALIb);
1448         else
1449             m_formatter.oneByteOp8(OP_GROUP3_EbIb, GROUP3_OP_TEST, dst);
1450         m_formatter.immediate8(imm);
1451     }
1452
1453     void setCC_r(Condition cond, RegisterID dst)
1454     {
1455         m_formatter.twoByteOp8(setccOpcode(cond), (GroupOpcodeID)0, dst);
1456     }
1457
1458     void sete_r(RegisterID dst)
1459     {
1460         m_formatter.twoByteOp8(setccOpcode(ConditionE), (GroupOpcodeID)0, dst);
1461     }
1462
1463     void setz_r(RegisterID dst)
1464     {
1465         sete_r(dst);
1466     }
1467
1468     void setne_r(RegisterID dst)
1469     {
1470         m_formatter.twoByteOp8(setccOpcode(ConditionNE), (GroupOpcodeID)0, dst);
1471     }
1472
1473     void setnz_r(RegisterID dst)
1474     {
1475         setne_r(dst);
1476     }
1477
1478     void setnp_r(RegisterID dst)
1479     {
1480         m_formatter.twoByteOp8(setccOpcode(ConditionNP), (GroupOpcodeID)0, dst);
1481     }
1482
1483     void setp_r(RegisterID dst)
1484     {
1485         m_formatter.twoByteOp8(setccOpcode(ConditionP), (GroupOpcodeID)0, dst);
1486     }
1487
1488     // Various move ops:
1489
1490     void cdq()
1491     {
1492         m_formatter.oneByteOp(OP_CDQ);
1493     }
1494
1495 #if CPU(X86_64)
1496     void cqo()
1497     {
1498         m_formatter.oneByteOp64(OP_CDQ);
1499     }
1500 #endif
1501
1502     void fstps(int offset, RegisterID base)
1503     {
1504         m_formatter.oneByteOp(OP_ESCAPE_D9, ESCAPE_D9_FSTP_singleReal, base, offset);
1505     }
1506
1507     void fstpl(int offset, RegisterID base)
1508     {
1509         m_formatter.oneByteOp(OP_ESCAPE_DD, ESCAPE_DD_FSTP_doubleReal, base, offset);
1510     }
1511
1512     void xchgl_rr(RegisterID src, RegisterID dst)
1513     {
1514         if (src == X86Registers::eax)
1515             m_formatter.oneByteOp(OP_XCHG_EAX, dst);
1516         else if (dst == X86Registers::eax)
1517             m_formatter.oneByteOp(OP_XCHG_EAX, src);
1518         else
1519             m_formatter.oneByteOp(OP_XCHG_EvGv, src, dst);
1520     }
1521
1522     void xchgl_rm(RegisterID src, int offset, RegisterID base)
1523     {
1524         m_formatter.oneByteOp(OP_XCHG_EvGv, src, base, offset);
1525     }
1526
1527 #if CPU(X86_64)
1528     void xchgq_rr(RegisterID src, RegisterID dst)
1529     {
1530         if (src == X86Registers::eax)
1531             m_formatter.oneByteOp64(OP_XCHG_EAX, dst);
1532         else if (dst == X86Registers::eax)
1533             m_formatter.oneByteOp64(OP_XCHG_EAX, src);
1534         else
1535             m_formatter.oneByteOp64(OP_XCHG_EvGv, src, dst);
1536     }
1537
1538     void xchgq_rm(RegisterID src, int offset, RegisterID base)
1539     {
1540         m_formatter.oneByteOp64(OP_XCHG_EvGv, src, base, offset);
1541     }
1542 #endif
1543
1544     void movl_rr(RegisterID src, RegisterID dst)
1545     {
1546         m_formatter.oneByteOp(OP_MOV_EvGv, src, dst);
1547     }
1548
1549     void movl_rm(RegisterID src, int offset, RegisterID base)
1550     {
1551         m_formatter.oneByteOp(OP_MOV_EvGv, src, base, offset);
1552     }
1553
1554     void movl_rm_disp32(RegisterID src, int offset, RegisterID base)
1555     {
1556         m_formatter.oneByteOp_disp32(OP_MOV_EvGv, src, base, offset);
1557     }
1558
1559     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1560     {
1561         m_formatter.oneByteOp(OP_MOV_EvGv, src, base, index, scale, offset);
1562     }
1563
1564     void movl_mEAX(const void* addr)
1565     {
1566         m_formatter.oneByteOp(OP_MOV_EAXOv);
1567 #if CPU(X86_64)
1568         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1569 #else
1570         m_formatter.immediate32(reinterpret_cast<int>(addr));
1571 #endif
1572     }
1573
1574     void movl_mr(int offset, RegisterID base, RegisterID dst)
1575     {
1576         m_formatter.oneByteOp(OP_MOV_GvEv, dst, base, offset);
1577     }
1578
1579     void movl_mr_disp32(int offset, RegisterID base, RegisterID dst)
1580     {
1581         m_formatter.oneByteOp_disp32(OP_MOV_GvEv, dst, base, offset);
1582     }
1583
1584     void movl_mr_disp8(int offset, RegisterID base, RegisterID dst)
1585     {
1586         m_formatter.oneByteOp_disp8(OP_MOV_GvEv, dst, base, offset);
1587     }
1588
1589     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1590     {
1591         m_formatter.oneByteOp(OP_MOV_GvEv, dst, base, index, scale, offset);
1592     }
1593
1594     void movl_i32r(int imm, RegisterID dst)
1595     {
1596         m_formatter.oneByteOp(OP_MOV_EAXIv, dst);
1597         m_formatter.immediate32(imm);
1598     }
1599
1600     void movl_i32m(int imm, int offset, RegisterID base)
1601     {
1602         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, base, offset);
1603         m_formatter.immediate32(imm);
1604     }
1605
1606     void movl_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1607     {
1608         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, base, index, scale, offset);
1609         m_formatter.immediate32(imm);
1610     }
1611
1612 #if !CPU(X86_64)
1613     void movb_i8m(int imm, const void* addr)
1614     {
1615         ASSERT(-128 <= imm && imm < 128);
1616         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, addr);
1617         m_formatter.immediate8(imm);
1618     }
1619 #endif
1620
1621     void movb_i8m(int imm, int offset, RegisterID base)
1622     {
1623         ASSERT(-128 <= imm && imm < 128);
1624         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, base, offset);
1625         m_formatter.immediate8(imm);
1626     }
1627
1628     void movb_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1629     {
1630         ASSERT(-128 <= imm && imm < 128);
1631         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, base, index, scale, offset);
1632         m_formatter.immediate8(imm);
1633     }
1634
1635 #if !CPU(X86_64)
1636     void movb_rm(RegisterID src, const void* addr)
1637     {
1638         m_formatter.oneByteOp(OP_MOV_EbGb, src, addr);
1639     }
1640 #endif
1641
1642     void movb_rm(RegisterID src, int offset, RegisterID base)
1643     {
1644         m_formatter.oneByteOp8(OP_MOV_EbGb, src, base, offset);
1645     }
1646
1647     void movb_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1648     {
1649         m_formatter.oneByteOp8(OP_MOV_EbGb, src, base, index, scale, offset);
1650     }
1651
1652     void movw_rm(RegisterID src, int offset, RegisterID base)
1653     {
1654         m_formatter.prefix(PRE_OPERAND_SIZE);
1655
1656         // FIXME: We often use oneByteOp8 for 16-bit operations. It's not clear that this is
1657         // necessary. https://bugs.webkit.org/show_bug.cgi?id=153433
1658         m_formatter.oneByteOp8(OP_MOV_EvGv, src, base, offset);
1659     }
1660
1661     void movw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1662     {
1663         m_formatter.prefix(PRE_OPERAND_SIZE);
1664         m_formatter.oneByteOp8(OP_MOV_EvGv, src, base, index, scale, offset);
1665     }
1666
1667     void movl_EAXm(const void* addr)
1668     {
1669         m_formatter.oneByteOp(OP_MOV_OvEAX);
1670 #if CPU(X86_64)
1671         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1672 #else
1673         m_formatter.immediate32(reinterpret_cast<int>(addr));
1674 #endif
1675     }
1676
1677 #if CPU(X86_64)
1678     void movq_rr(RegisterID src, RegisterID dst)
1679     {
1680         m_formatter.oneByteOp64(OP_MOV_EvGv, src, dst);
1681     }
1682
1683     void movq_rm(RegisterID src, int offset, RegisterID base)
1684     {
1685         m_formatter.oneByteOp64(OP_MOV_EvGv, src, base, offset);
1686     }
1687
1688     void movq_rm_disp32(RegisterID src, int offset, RegisterID base)
1689     {
1690         m_formatter.oneByteOp64_disp32(OP_MOV_EvGv, src, base, offset);
1691     }
1692
1693     void movq_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1694     {
1695         m_formatter.oneByteOp64(OP_MOV_EvGv, src, base, index, scale, offset);
1696     }
1697
1698     void movq_mEAX(const void* addr)
1699     {
1700         m_formatter.oneByteOp64(OP_MOV_EAXOv);
1701         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1702     }
1703
1704     void movq_EAXm(const void* addr)
1705     {
1706         m_formatter.oneByteOp64(OP_MOV_OvEAX);
1707         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1708     }
1709
1710     void movq_mr(int offset, RegisterID base, RegisterID dst)
1711     {
1712         m_formatter.oneByteOp64(OP_MOV_GvEv, dst, base, offset);
1713     }
1714
1715     void movq_mr_disp32(int offset, RegisterID base, RegisterID dst)
1716     {
1717         m_formatter.oneByteOp64_disp32(OP_MOV_GvEv, dst, base, offset);
1718     }
1719
1720     void movq_mr_disp8(int offset, RegisterID base, RegisterID dst)
1721     {
1722         m_formatter.oneByteOp64_disp8(OP_MOV_GvEv, dst, base, offset);
1723     }
1724
1725     void movq_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1726     {
1727         m_formatter.oneByteOp64(OP_MOV_GvEv, dst, base, index, scale, offset);
1728     }
1729
1730     void movq_i32m(int imm, int offset, RegisterID base)
1731     {
1732         m_formatter.oneByteOp64(OP_GROUP11_EvIz, GROUP11_MOV, base, offset);
1733         m_formatter.immediate32(imm);
1734     }
1735
1736     void movq_i64r(int64_t imm, RegisterID dst)
1737     {
1738         m_formatter.oneByteOp64(OP_MOV_EAXIv, dst);
1739         m_formatter.immediate64(imm);
1740     }
1741
1742     void mov_i32r(int32_t imm, RegisterID dst)
1743     {
1744         m_formatter.oneByteOp64(OP_GROUP11_EvIz, GROUP11_MOV, dst);
1745         m_formatter.immediate32(imm);
1746     }
1747
1748     void movsxd_rr(RegisterID src, RegisterID dst)
1749     {
1750         m_formatter.oneByteOp64(OP_MOVSXD_GvEv, dst, src);
1751     }
1752
1753
1754 #else
1755     void movl_rm(RegisterID src, const void* addr)
1756     {
1757         if (src == X86Registers::eax)
1758             movl_EAXm(addr);
1759         else
1760             m_formatter.oneByteOp(OP_MOV_EvGv, src, addr);
1761     }
1762
1763     void movl_mr(const void* addr, RegisterID dst)
1764     {
1765         if (dst == X86Registers::eax)
1766             movl_mEAX(addr);
1767         else
1768             m_formatter.oneByteOp(OP_MOV_GvEv, dst, addr);
1769     }
1770
1771     void movl_i32m(int imm, const void* addr)
1772     {
1773         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, addr);
1774         m_formatter.immediate32(imm);
1775     }
1776 #endif
1777
1778     void movzwl_mr(int offset, RegisterID base, RegisterID dst)
1779     {
1780         m_formatter.twoByteOp(OP2_MOVZX_GvEw, dst, base, offset);
1781     }
1782
1783     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1784     {
1785         m_formatter.twoByteOp(OP2_MOVZX_GvEw, dst, base, index, scale, offset);
1786     }
1787
1788     void movswl_mr(int offset, RegisterID base, RegisterID dst)
1789     {
1790         m_formatter.twoByteOp(OP2_MOVSX_GvEw, dst, base, offset);
1791     }
1792
1793     void movswl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1794     {
1795         m_formatter.twoByteOp(OP2_MOVSX_GvEw, dst, base, index, scale, offset);
1796     }
1797
1798     void movzbl_mr(int offset, RegisterID base, RegisterID dst)
1799     {
1800         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, base, offset);
1801     }
1802
1803     void movzbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1804     {
1805         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, base, index, scale, offset);
1806     }
1807
1808 #if !CPU(X86_64)
1809     void movzbl_mr(const void* address, RegisterID dst)
1810     {
1811         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, address);
1812     }
1813 #endif
1814
1815     void movsbl_mr(int offset, RegisterID base, RegisterID dst)
1816     {
1817         m_formatter.twoByteOp(OP2_MOVSX_GvEb, dst, base, offset);
1818     }
1819
1820     void movsbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1821     {
1822         m_formatter.twoByteOp(OP2_MOVSX_GvEb, dst, base, index, scale, offset);
1823     }
1824
1825     void movzbl_rr(RegisterID src, RegisterID dst)
1826     {
1827         // In 64-bit, this may cause an unnecessary REX to be planted (if the dst register
1828         // is in the range ESP-EDI, and the src would not have required a REX).  Unneeded
1829         // REX prefixes are defined to be silently ignored by the processor.
1830         m_formatter.twoByteOp8(OP2_MOVZX_GvEb, dst, src);
1831     }
1832
1833     void movsbl_rr(RegisterID src, RegisterID dst)
1834     {
1835         m_formatter.twoByteOp8(OP2_MOVSX_GvEb, dst, src);
1836     }
1837
1838     void movzwl_rr(RegisterID src, RegisterID dst)
1839     {
1840         m_formatter.twoByteOp8(OP2_MOVZX_GvEw, dst, src);
1841     }
1842
1843     void movswl_rr(RegisterID src, RegisterID dst)
1844     {
1845         m_formatter.twoByteOp8(OP2_MOVSX_GvEw, dst, src);
1846     }
1847
1848     void cmovl_rr(Condition cond, RegisterID src, RegisterID dst)
1849     {
1850         m_formatter.twoByteOp(cmovcc(cond), dst, src);
1851     }
1852
1853     void cmovl_mr(Condition cond, int offset, RegisterID base, RegisterID dst)
1854     {
1855         m_formatter.twoByteOp(cmovcc(cond), dst, base, offset);
1856     }
1857
1858     void cmovl_mr(Condition cond, int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1859     {
1860         m_formatter.twoByteOp(cmovcc(cond), dst, base, index, scale, offset);
1861     }
1862
1863     void cmovel_rr(RegisterID src, RegisterID dst)
1864     {
1865         m_formatter.twoByteOp(cmovcc(ConditionE), dst, src);
1866     }
1867
1868     void cmovnel_rr(RegisterID src, RegisterID dst)
1869     {
1870         m_formatter.twoByteOp(cmovcc(ConditionNE), dst, src);
1871     }
1872
1873     void cmovpl_rr(RegisterID src, RegisterID dst)
1874     {
1875         m_formatter.twoByteOp(cmovcc(ConditionP), dst, src);
1876     }
1877
1878     void cmovnpl_rr(RegisterID src, RegisterID dst)
1879     {
1880         m_formatter.twoByteOp(cmovcc(ConditionNP), dst, src);
1881     }
1882
1883 #if CPU(X86_64)
1884     void cmovq_rr(Condition cond, RegisterID src, RegisterID dst)
1885     {
1886         m_formatter.twoByteOp64(cmovcc(cond), dst, src);
1887     }
1888
1889     void cmovq_mr(Condition cond, int offset, RegisterID base, RegisterID dst)
1890     {
1891         m_formatter.twoByteOp64(cmovcc(cond), dst, base, offset);
1892     }
1893
1894     void cmovq_mr(Condition cond, int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1895     {
1896         m_formatter.twoByteOp64(cmovcc(cond), dst, base, index, scale, offset);
1897     }
1898
1899     void cmoveq_rr(RegisterID src, RegisterID dst)
1900     {
1901         m_formatter.twoByteOp64(cmovcc(ConditionE), dst, src);
1902     }
1903
1904     void cmovneq_rr(RegisterID src, RegisterID dst)
1905     {
1906         m_formatter.twoByteOp64(cmovcc(ConditionNE), dst, src);
1907     }
1908
1909     void cmovpq_rr(RegisterID src, RegisterID dst)
1910     {
1911         m_formatter.twoByteOp64(cmovcc(ConditionP), dst, src);
1912     }
1913
1914     void cmovnpq_rr(RegisterID src, RegisterID dst)
1915     {
1916         m_formatter.twoByteOp64(cmovcc(ConditionNP), dst, src);
1917     }
1918 #else
1919     void cmovl_mr(Condition cond, const void* addr, RegisterID dst)
1920     {
1921         m_formatter.twoByteOp(cmovcc(cond), dst, addr);
1922     }
1923 #endif
1924
1925     void leal_mr(int offset, RegisterID base, RegisterID dst)
1926     {
1927         m_formatter.oneByteOp(OP_LEA, dst, base, offset);
1928     }
1929
1930     void leal_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1931     {
1932         m_formatter.oneByteOp(OP_LEA, dst, base, index, scale, offset);
1933     }
1934
1935 #if CPU(X86_64)
1936     void leaq_mr(int offset, RegisterID base, RegisterID dst)
1937     {
1938         m_formatter.oneByteOp64(OP_LEA, dst, base, offset);
1939     }
1940
1941     void leaq_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1942     {
1943         m_formatter.oneByteOp64(OP_LEA, dst, base, index, scale, offset);
1944     }
1945 #endif
1946
1947     // Flow control:
1948
1949     AssemblerLabel call()
1950     {
1951         m_formatter.oneByteOp(OP_CALL_rel32);
1952         return m_formatter.immediateRel32();
1953     }
1954
1955     AssemblerLabel call(RegisterID dst)
1956     {
1957         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_CALLN, dst);
1958         return m_formatter.label();
1959     }
1960
1961     void call_m(int offset, RegisterID base)
1962     {
1963         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_CALLN, base, offset);
1964     }
1965
1966     AssemblerLabel jmp()
1967     {
1968         m_formatter.oneByteOp(OP_JMP_rel32);
1969         return m_formatter.immediateRel32();
1970     }
1971
1972     // Return a AssemblerLabel so we have a label to the jump, so we can use this
1973     // To make a tail recursive call on x86-64.  The MacroAssembler
1974     // really shouldn't wrap this as a Jump, since it can't be linked. :-/
1975     AssemblerLabel jmp_r(RegisterID dst)
1976     {
1977         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, dst);
1978         return m_formatter.label();
1979     }
1980
1981     void jmp_m(int offset, RegisterID base)
1982     {
1983         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, offset);
1984     }
1985
1986     void jmp_m(int offset, RegisterID base, RegisterID index, int scale)
1987     {
1988         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, index, scale, offset);
1989     }
1990
1991 #if !CPU(X86_64)
1992     void jmp_m(const void* address)
1993     {
1994         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, address);
1995     }
1996 #endif
1997
1998     AssemblerLabel jne()
1999     {
2000         m_formatter.twoByteOp(jccRel32(ConditionNE));
2001         return m_formatter.immediateRel32();
2002     }
2003
2004     AssemblerLabel jnz()
2005     {
2006         return jne();
2007     }
2008
2009     AssemblerLabel je()
2010     {
2011         m_formatter.twoByteOp(jccRel32(ConditionE));
2012         return m_formatter.immediateRel32();
2013     }
2014
2015     AssemblerLabel jz()
2016     {
2017         return je();
2018     }
2019
2020     AssemblerLabel jl()
2021     {
2022         m_formatter.twoByteOp(jccRel32(ConditionL));
2023         return m_formatter.immediateRel32();
2024     }
2025
2026     AssemblerLabel jb()
2027     {
2028         m_formatter.twoByteOp(jccRel32(ConditionB));
2029         return m_formatter.immediateRel32();
2030     }
2031
2032     AssemblerLabel jle()
2033     {
2034         m_formatter.twoByteOp(jccRel32(ConditionLE));
2035         return m_formatter.immediateRel32();
2036     }
2037
2038     AssemblerLabel jbe()
2039     {
2040         m_formatter.twoByteOp(jccRel32(ConditionBE));
2041         return m_formatter.immediateRel32();
2042     }
2043
2044     AssemblerLabel jge()
2045     {
2046         m_formatter.twoByteOp(jccRel32(ConditionGE));
2047         return m_formatter.immediateRel32();
2048     }
2049
2050     AssemblerLabel jg()
2051     {
2052         m_formatter.twoByteOp(jccRel32(ConditionG));
2053         return m_formatter.immediateRel32();
2054     }
2055
2056     AssemblerLabel ja()
2057     {
2058         m_formatter.twoByteOp(jccRel32(ConditionA));
2059         return m_formatter.immediateRel32();
2060     }
2061
2062     AssemblerLabel jae()
2063     {
2064         m_formatter.twoByteOp(jccRel32(ConditionAE));
2065         return m_formatter.immediateRel32();
2066     }
2067
2068     AssemblerLabel jo()
2069     {
2070         m_formatter.twoByteOp(jccRel32(ConditionO));
2071         return m_formatter.immediateRel32();
2072     }
2073
2074     AssemblerLabel jnp()
2075     {
2076         m_formatter.twoByteOp(jccRel32(ConditionNP));
2077         return m_formatter.immediateRel32();
2078     }
2079
2080     AssemblerLabel jp()
2081     {
2082         m_formatter.twoByteOp(jccRel32(ConditionP));
2083         return m_formatter.immediateRel32();
2084     }
2085
2086     AssemblerLabel js()
2087     {
2088         m_formatter.twoByteOp(jccRel32(ConditionS));
2089         return m_formatter.immediateRel32();
2090     }
2091
2092     AssemblerLabel jCC(Condition cond)
2093     {
2094         m_formatter.twoByteOp(jccRel32(cond));
2095         return m_formatter.immediateRel32();
2096     }
2097
2098     // SSE operations:
2099
2100     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
2101     {
2102         m_formatter.prefix(PRE_SSE_F2);
2103         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2104     }
2105
2106     void vaddsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2107     {
2108         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2109     }
2110
2111     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2112     {
2113         m_formatter.prefix(PRE_SSE_F2);
2114         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, base, offset);
2115     }
2116
2117     void addsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2118     {
2119         m_formatter.prefix(PRE_SSE_F2);
2120         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, dst, base, index, scale, offset);
2121     }
2122
2123     void vaddsd_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2124     {
2125         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2126     }
2127
2128     void vaddsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2129     {
2130         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2131     }
2132
2133     void addss_rr(XMMRegisterID src, XMMRegisterID dst)
2134     {
2135         m_formatter.prefix(PRE_SSE_F3);
2136         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2137     }
2138
2139     void vaddss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2140     {
2141         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2142     }
2143
2144     void addss_mr(int offset, RegisterID base, XMMRegisterID dst)
2145     {
2146         m_formatter.prefix(PRE_SSE_F3);
2147         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, base, offset);
2148     }
2149
2150     void addss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2151     {
2152         m_formatter.prefix(PRE_SSE_F3);
2153         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, dst, base, index, scale, offset);
2154     }
2155
2156     void vaddss_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2157     {
2158         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2159     }
2160
2161     void vaddss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2162     {
2163         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2164     }
2165
2166 #if !CPU(X86_64)
2167     void addsd_mr(const void* address, XMMRegisterID dst)
2168     {
2169         m_formatter.prefix(PRE_SSE_F2);
2170         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, address);
2171     }
2172 #endif
2173
2174     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
2175     {
2176         m_formatter.prefix(PRE_SSE_F2);
2177         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2178     }
2179
2180     void cvtsi2ss_rr(RegisterID src, XMMRegisterID dst)
2181     {
2182         m_formatter.prefix(PRE_SSE_F3);
2183         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2184     }
2185
2186 #if CPU(X86_64)
2187     void cvtsi2sdq_rr(RegisterID src, XMMRegisterID dst)
2188     {
2189         m_formatter.prefix(PRE_SSE_F2);
2190         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2191     }
2192
2193     void cvtsi2ssq_rr(RegisterID src, XMMRegisterID dst)
2194     {
2195         m_formatter.prefix(PRE_SSE_F3);
2196         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2197     }
2198
2199     void cvtsi2sdq_mr(int offset, RegisterID base, XMMRegisterID dst)
2200     {
2201         m_formatter.prefix(PRE_SSE_F2);
2202         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2203     }
2204
2205     void cvtsi2ssq_mr(int offset, RegisterID base, XMMRegisterID dst)
2206     {
2207         m_formatter.prefix(PRE_SSE_F3);
2208         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2209     }
2210 #endif
2211
2212     void cvtsi2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
2213     {
2214         m_formatter.prefix(PRE_SSE_F2);
2215         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2216     }
2217
2218     void cvtsi2ss_mr(int offset, RegisterID base, XMMRegisterID dst)
2219     {
2220         m_formatter.prefix(PRE_SSE_F3);
2221         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2222     }
2223
2224 #if !CPU(X86_64)
2225     void cvtsi2sd_mr(const void* address, XMMRegisterID dst)
2226     {
2227         m_formatter.prefix(PRE_SSE_F2);
2228         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, address);
2229     }
2230 #endif
2231
2232     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
2233     {
2234         m_formatter.prefix(PRE_SSE_F2);
2235         m_formatter.twoByteOp(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
2236     }
2237
2238     void cvtsd2ss_rr(XMMRegisterID src, XMMRegisterID dst)
2239     {
2240         m_formatter.prefix(PRE_SSE_F2);
2241         m_formatter.twoByteOp(OP2_CVTSD2SS_VsdWsd, dst, (RegisterID)src);
2242     }
2243
2244     void cvtsd2ss_mr(int offset, RegisterID base, XMMRegisterID dst)
2245     {
2246         m_formatter.prefix(PRE_SSE_F2);
2247         m_formatter.twoByteOp(OP2_CVTSD2SS_VsdWsd, dst, base, offset);
2248     }
2249
2250     void cvtss2sd_rr(XMMRegisterID src, XMMRegisterID dst)
2251     {
2252         m_formatter.prefix(PRE_SSE_F3);
2253         m_formatter.twoByteOp(OP2_CVTSS2SD_VsdWsd, dst, (RegisterID)src);
2254     }
2255
2256     void cvtss2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
2257     {
2258         m_formatter.prefix(PRE_SSE_F3);
2259         m_formatter.twoByteOp(OP2_CVTSS2SD_VsdWsd, dst, base, offset);
2260     }
2261
2262 #if CPU(X86_64)
2263     void cvttsd2siq_rr(XMMRegisterID src, RegisterID dst)
2264     {
2265         m_formatter.prefix(PRE_SSE_F2);
2266         m_formatter.twoByteOp64(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
2267     }
2268 #endif
2269
2270     void movd_rr(XMMRegisterID src, RegisterID dst)
2271     {
2272         m_formatter.prefix(PRE_SSE_66);
2273         m_formatter.twoByteOp(OP2_MOVD_EdVd, (RegisterID)src, dst);
2274     }
2275
2276     void movd_rr(RegisterID src, XMMRegisterID dst)
2277     {
2278         m_formatter.prefix(PRE_SSE_66);
2279         m_formatter.twoByteOp(OP2_MOVD_VdEd, (RegisterID)dst, src);
2280     }
2281
2282 #if CPU(X86_64)
2283     void movmskpd_rr(XMMRegisterID src, RegisterID dst)
2284     {
2285         m_formatter.prefix(PRE_SSE_66);
2286         m_formatter.twoByteOp64(OP2_MOVMSKPD_VdEd, dst, (RegisterID)src);
2287     }
2288
2289     void movq_rr(XMMRegisterID src, RegisterID dst)
2290     {
2291         m_formatter.prefix(PRE_SSE_66);
2292         m_formatter.twoByteOp64(OP2_MOVD_EdVd, (RegisterID)src, dst);
2293     }
2294
2295     void movq_rr(RegisterID src, XMMRegisterID dst)
2296     {
2297         m_formatter.prefix(PRE_SSE_66);
2298         m_formatter.twoByteOp64(OP2_MOVD_VdEd, (RegisterID)dst, src);
2299     }
2300 #endif
2301
2302     void movapd_rr(XMMRegisterID src, XMMRegisterID dst)
2303     {
2304         m_formatter.prefix(PRE_SSE_66);
2305         m_formatter.twoByteOp(OP2_MOVAPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2306     }
2307
2308     void movaps_rr(XMMRegisterID src, XMMRegisterID dst)
2309     {
2310         m_formatter.twoByteOp(OP2_MOVAPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
2311     }
2312
2313     void movsd_rr(XMMRegisterID src, XMMRegisterID dst)
2314     {
2315         m_formatter.prefix(PRE_SSE_F2);
2316         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2317     }
2318
2319     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
2320     {
2321         m_formatter.prefix(PRE_SSE_F2);
2322         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, offset);
2323     }
2324
2325     void movsd_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
2326     {
2327         m_formatter.prefix(PRE_SSE_F2);
2328         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
2329     }
2330
2331     void movss_rm(XMMRegisterID src, int offset, RegisterID base)
2332     {
2333         m_formatter.prefix(PRE_SSE_F3);
2334         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, offset);
2335     }
2336
2337     void movss_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
2338     {
2339         m_formatter.prefix(PRE_SSE_F3);
2340         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
2341     }
2342
2343     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2344     {
2345         m_formatter.prefix(PRE_SSE_F2);
2346         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, base, offset);
2347     }
2348
2349     void movsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2350     {
2351         m_formatter.prefix(PRE_SSE_F2);
2352         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
2353     }
2354
2355     void movss_mr(int offset, RegisterID base, XMMRegisterID dst)
2356     {
2357         m_formatter.prefix(PRE_SSE_F3);
2358         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, base, offset);
2359     }
2360
2361     void movss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2362     {
2363         m_formatter.prefix(PRE_SSE_F3);
2364         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
2365     }
2366
2367 #if !CPU(X86_64)
2368     void movsd_mr(const void* address, XMMRegisterID dst)
2369     {
2370         m_formatter.prefix(PRE_SSE_F2);
2371         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, address);
2372     }
2373     void movsd_rm(XMMRegisterID src, const void* address)
2374     {
2375         m_formatter.prefix(PRE_SSE_F2);
2376         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, address);
2377     }
2378 #endif
2379
2380     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
2381     {
2382         m_formatter.prefix(PRE_SSE_F2);
2383         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2384     }
2385
2386     void vmulsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2387     {
2388         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2389     }
2390
2391     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2392     {
2393         m_formatter.prefix(PRE_SSE_F2);
2394         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, base, offset);
2395     }
2396
2397     void mulsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2398     {
2399         m_formatter.prefix(PRE_SSE_F2);
2400         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, dst, base, index, scale, offset);
2401     }
2402
2403     void vmulsd_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2404     {
2405         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2406     }
2407
2408     void vmulsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2409     {
2410         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2411     }
2412
2413     void mulss_rr(XMMRegisterID src, XMMRegisterID dst)
2414     {
2415         m_formatter.prefix(PRE_SSE_F3);
2416         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2417     }
2418
2419     void vmulss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2420     {
2421         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2422     }
2423
2424     void mulss_mr(int offset, RegisterID base, XMMRegisterID dst)
2425     {
2426         m_formatter.prefix(PRE_SSE_F3);
2427         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, base, offset);
2428     }
2429
2430     void mulss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2431     {
2432         m_formatter.prefix(PRE_SSE_F3);
2433         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, dst, base, index, scale, offset);
2434     }
2435
2436     void vmulss_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2437     {
2438         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2439     }
2440
2441     void vmulss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2442     {
2443         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2444     }
2445
2446     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
2447     {
2448         m_formatter.prefix(PRE_SSE_66);
2449         m_formatter.twoByteOp(OP2_PEXTRW_GdUdIb, (RegisterID)dst, (RegisterID)src);
2450         m_formatter.immediate8(whichWord);
2451     }
2452
2453     void psllq_i8r(int imm, XMMRegisterID dst)
2454     {
2455         m_formatter.prefix(PRE_SSE_66);
2456         m_formatter.twoByteOp8(OP2_PSLLQ_UdqIb, GROUP14_OP_PSLLQ, (RegisterID)dst);
2457         m_formatter.immediate8(imm);
2458     }
2459
2460     void psrlq_i8r(int imm, XMMRegisterID dst)
2461     {
2462         m_formatter.prefix(PRE_SSE_66);
2463         m_formatter.twoByteOp8(OP2_PSRLQ_UdqIb, GROUP14_OP_PSRLQ, (RegisterID)dst);
2464         m_formatter.immediate8(imm);
2465     }
2466
2467     void por_rr(XMMRegisterID src, XMMRegisterID dst)
2468     {
2469         m_formatter.prefix(PRE_SSE_66);
2470         m_formatter.twoByteOp(OP2_POR_VdqWdq, (RegisterID)dst, (RegisterID)src);
2471     }
2472
2473     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
2474     {
2475         m_formatter.prefix(PRE_SSE_F2);
2476         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2477     }
2478
2479     void vsubsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2480     {
2481         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2482     }
2483
2484     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2485     {
2486         m_formatter.prefix(PRE_SSE_F2);
2487         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, base, offset);
2488     }
2489
2490     void subsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2491     {
2492         m_formatter.prefix(PRE_SSE_F2);
2493         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, dst, base, index, scale, offset);
2494     }
2495
2496     void vsubsd_mr(XMMRegisterID b, int offset, RegisterID base, XMMRegisterID dst)
2497     {
2498         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2499     }
2500
2501     void vsubsd_mr(XMMRegisterID b, int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2502     {
2503         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2504     }
2505
2506     void subss_rr(XMMRegisterID src, XMMRegisterID dst)
2507     {
2508         m_formatter.prefix(PRE_SSE_F3);
2509         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2510     }
2511
2512     void vsubss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2513     {
2514         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2515     }
2516
2517     void subss_mr(int offset, RegisterID base, XMMRegisterID dst)
2518     {
2519         m_formatter.prefix(PRE_SSE_F3);
2520         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, base, offset);
2521     }
2522
2523     void subss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2524     {
2525         m_formatter.prefix(PRE_SSE_F3);
2526         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, dst, base, index, scale, offset);
2527     }
2528
2529     void vsubss_mr(XMMRegisterID b, int offset, RegisterID base, XMMRegisterID dst)
2530     {
2531         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2532     }
2533
2534     void vsubss_mr(XMMRegisterID b, int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2535     {
2536         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2537     }
2538
2539     void ucomisd_rr(XMMRegisterID src, XMMRegisterID dst)
2540     {
2541         m_formatter.prefix(PRE_SSE_66);
2542         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2543     }
2544
2545     void ucomisd_mr(int offset, RegisterID base, XMMRegisterID dst)
2546     {
2547         m_formatter.prefix(PRE_SSE_66);
2548         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, base, offset);
2549     }
2550
2551     void ucomiss_rr(XMMRegisterID src, XMMRegisterID dst)
2552     {
2553         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2554     }
2555
2556     void ucomiss_mr(int offset, RegisterID base, XMMRegisterID dst)
2557     {
2558         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, base, offset);
2559     }
2560
2561     void divsd_rr(XMMRegisterID src, XMMRegisterID dst)
2562     {
2563         m_formatter.prefix(PRE_SSE_F2);
2564         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2565     }
2566
2567     void divsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2568     {
2569         m_formatter.prefix(PRE_SSE_F2);
2570         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, base, offset);
2571     }
2572
2573     void divss_rr(XMMRegisterID src, XMMRegisterID dst)
2574     {
2575         m_formatter.prefix(PRE_SSE_F3);
2576         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2577     }
2578
2579     void divss_mr(int offset, RegisterID base, XMMRegisterID dst)
2580     {
2581         m_formatter.prefix(PRE_SSE_F3);
2582         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, base, offset);
2583     }
2584
2585     void andps_rr(XMMRegisterID src, XMMRegisterID dst)
2586     {
2587         m_formatter.twoByteOp(OP2_ANDPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
2588     }
2589
2590     void xorps_rr(XMMRegisterID src, XMMRegisterID dst)
2591     {
2592         m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2593     }
2594
2595     void xorpd_rr(XMMRegisterID src, XMMRegisterID dst)
2596     {
2597         if (src == dst) {
2598             xorps_rr(src, dst);
2599             return;
2600         }
2601         m_formatter.prefix(PRE_SSE_66);
2602         m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2603     }
2604
2605     void andnpd_rr(XMMRegisterID src, XMMRegisterID dst)
2606     {
2607         m_formatter.prefix(PRE_SSE_66);
2608         m_formatter.twoByteOp(OP2_ANDNPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2609     }
2610
2611     void sqrtsd_rr(XMMRegisterID src, XMMRegisterID dst)
2612     {
2613         m_formatter.prefix(PRE_SSE_F2);
2614         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2615     }
2616
2617     void sqrtsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2618     {
2619         m_formatter.prefix(PRE_SSE_F2);
2620         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, base, offset);
2621     }
2622
2623     void sqrtss_rr(XMMRegisterID src, XMMRegisterID dst)
2624     {
2625         m_formatter.prefix(PRE_SSE_F3);
2626         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2627     }
2628
2629     void sqrtss_mr(int offset, RegisterID base, XMMRegisterID dst)
2630     {
2631         m_formatter.prefix(PRE_SSE_F3);
2632         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, base, offset);
2633     }
2634
2635     enum class RoundingType : uint8_t {
2636         ToNearestWithTiesToEven = 0,
2637         TowardNegativeInfiniti = 1,
2638         TowardInfiniti = 2,
2639         TowardZero = 3
2640     };
2641
2642     void roundss_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
2643     {
2644         m_formatter.prefix(PRE_SSE_66);
2645         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, (RegisterID)src);
2646         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2647     }
2648
2649     void roundss_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
2650     {
2651         m_formatter.prefix(PRE_SSE_66);
2652         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, base, offset);
2653         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2654     }
2655
2656     void roundsd_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
2657     {
2658         m_formatter.prefix(PRE_SSE_66);
2659         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, (RegisterID)src);
2660         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2661     }
2662
2663     void roundsd_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
2664     {
2665         m_formatter.prefix(PRE_SSE_66);
2666         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, base, offset);
2667         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2668     }
2669
2670     // Misc instructions:
2671
2672     void int3()
2673     {
2674         m_formatter.oneByteOp(OP_INT3);
2675     }
2676
2677     void ret()
2678     {
2679         m_formatter.oneByteOp(OP_RET);
2680     }
2681
2682     void predictNotTaken()
2683     {
2684         m_formatter.prefix(PRE_PREDICT_BRANCH_NOT_TAKEN);
2685     }
2686
2687     void mfence()
2688     {
2689         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_AE, OP3_MFENCE);
2690     }
2691
2692     // Assembler admin methods:
2693
2694     size_t codeSize() const
2695     {
2696         return m_formatter.codeSize();
2697     }
2698
2699     AssemblerLabel labelForWatchpoint()
2700     {
2701         AssemblerLabel result = m_formatter.label();
2702         if (static_cast<int>(result.m_offset) != m_indexOfLastWatchpoint)
2703             result = label();
2704         m_indexOfLastWatchpoint = result.m_offset;
2705         m_indexOfTailOfLastWatchpoint = result.m_offset + maxJumpReplacementSize();
2706         return result;
2707     }
2708
2709     AssemblerLabel labelIgnoringWatchpoints()
2710     {
2711         return m_formatter.label();
2712     }
2713
2714     AssemblerLabel label()
2715     {
2716         AssemblerLabel result = m_formatter.label();
2717         while (UNLIKELY(static_cast<int>(result.m_offset) < m_indexOfTailOfLastWatchpoint)) {
2718             nop();
2719             result = m_formatter.label();
2720         }
2721         return result;
2722     }
2723
2724     AssemblerLabel align(int alignment)
2725     {
2726         while (!m_formatter.isAligned(alignment))
2727             m_formatter.oneByteOp(OP_HLT);
2728
2729         return label();
2730     }
2731
2732     // Linking & patching:
2733     //
2734     // 'link' and 'patch' methods are for use on unprotected code - such as the code
2735     // within the AssemblerBuffer, and code being patched by the patch buffer.  Once
2736     // code has been finalized it is (platform support permitting) within a non-
2737     // writable region of memory; to modify the code in an execute-only execuable
2738     // pool the 'repatch' and 'relink' methods should be used.
2739
2740     void linkJump(AssemblerLabel from, AssemblerLabel to)
2741     {
2742         ASSERT(from.isSet());
2743         ASSERT(to.isSet());
2744
2745         char* code = reinterpret_cast<char*>(m_formatter.data());
2746         ASSERT(!reinterpret_cast<int32_t*>(code + from.m_offset)[-1]);
2747         setRel32(code + from.m_offset, code + to.m_offset);
2748     }
2749
2750     static void linkJump(void* code, AssemblerLabel from, void* to)
2751     {
2752         ASSERT(from.isSet());
2753
2754         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2755     }
2756
2757     static void linkCall(void* code, AssemblerLabel from, void* to)
2758     {
2759         ASSERT(from.isSet());
2760
2761         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2762     }
2763
2764     static void linkPointer(void* code, AssemblerLabel where, void* value)
2765     {
2766         ASSERT(where.isSet());
2767
2768         setPointer(reinterpret_cast<char*>(code) + where.m_offset, value);
2769     }
2770
2771     static void relinkJump(void* from, void* to)
2772     {
2773         setRel32(from, to);
2774     }
2775
2776     static void relinkCall(void* from, void* to)
2777     {
2778         setRel32(from, to);
2779     }
2780
2781     static void repatchCompact(void* where, int32_t value)
2782     {
2783         ASSERT(value >= std::numeric_limits<int8_t>::min());
2784         ASSERT(value <= std::numeric_limits<int8_t>::max());
2785         setInt8(where, value);
2786     }
2787
2788     static void repatchInt32(void* where, int32_t value)
2789     {
2790         setInt32(where, value);
2791     }
2792
2793     static void repatchPointer(void* where, void* value)
2794     {
2795         setPointer(where, value);
2796     }
2797
2798     static void* readPointer(void* where)
2799     {
2800         return reinterpret_cast<void**>(where)[-1];
2801     }
2802
2803     static void replaceWithJump(void* instructionStart, void* to)
2804     {
2805         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2806         uint8_t* dstPtr = reinterpret_cast<uint8_t*>(to);
2807         intptr_t distance = (intptr_t)(dstPtr - (ptr + 5));
2808         ptr[0] = static_cast<uint8_t>(OP_JMP_rel32);
2809         *reinterpret_cast<int32_t*>(ptr + 1) = static_cast<int32_t>(distance);
2810     }
2811
2812     static ptrdiff_t maxJumpReplacementSize()
2813     {
2814         return 5;
2815     }
2816
2817     static constexpr ptrdiff_t patchableJumpSize()
2818     {
2819         return 5;
2820     }
2821
2822 #if CPU(X86_64)
2823     static void revertJumpTo_movq_i64r(void* instructionStart, int64_t imm, RegisterID dst)
2824     {
2825         const unsigned instructionSize = 10; // REX.W MOV IMM64
2826         const int rexBytes = 1;
2827         const int opcodeBytes = 1;
2828         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2829         ptr[0] = PRE_REX | (1 << 3) | (dst >> 3);
2830         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2831
2832         union {
2833             uint64_t asWord;
2834             uint8_t asBytes[8];
2835         } u;
2836         u.asWord = imm;
2837         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2838             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2839     }
2840
2841     static void revertJumpTo_movl_i32r(void* instructionStart, int32_t imm, RegisterID dst)
2842     {
2843         // We only revert jumps on inline caches, and inline caches always use the scratch register (r11).
2844         // FIXME: If the above is ever false then we need to make this smarter with respect to emitting
2845         // the REX byte.
2846         ASSERT(dst == X86Registers::r11);
2847         const unsigned instructionSize = 6; // REX MOV IMM32
2848         const int rexBytes = 1;
2849         const int opcodeBytes = 1;
2850         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2851         ptr[0] = PRE_REX | (dst >> 3);
2852         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2853
2854         union {
2855             uint32_t asWord;
2856             uint8_t asBytes[4];
2857         } u;
2858         u.asWord = imm;
2859         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2860             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2861     }
2862 #endif
2863
2864     static void revertJumpTo_cmpl_ir_force32(void* instructionStart, int32_t imm, RegisterID dst)
2865     {
2866         const int opcodeBytes = 1;
2867         const int modRMBytes = 1;
2868         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2869         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2870         ptr[0] = OP_GROUP1_EvIz;
2871         ptr[1] = (X86InstructionFormatter::ModRmRegister << 6) | (GROUP1_OP_CMP << 3) | dst;
2872         union {
2873             uint32_t asWord;
2874             uint8_t asBytes[4];
2875         } u;
2876         u.asWord = imm;
2877         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2878             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2879     }
2880
2881     static void revertJumpTo_cmpl_im_force32(void* instructionStart, int32_t imm, int offset, RegisterID dst)
2882     {
2883         ASSERT_UNUSED(offset, !offset);
2884         const int opcodeBytes = 1;
2885         const int modRMBytes = 1;
2886         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2887         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2888         ptr[0] = OP_GROUP1_EvIz;
2889         ptr[1] = (X86InstructionFormatter::ModRmMemoryNoDisp << 6) | (GROUP1_OP_CMP << 3) | dst;
2890         union {
2891             uint32_t asWord;
2892             uint8_t asBytes[4];
2893         } u;
2894         u.asWord = imm;
2895         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2896             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2897     }
2898
2899     static void replaceWithLoad(void* instructionStart)
2900     {
2901         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2902 #if CPU(X86_64)
2903         if ((*ptr & ~15) == PRE_REX)
2904             ptr++;
2905 #endif
2906         switch (*ptr) {
2907         case OP_MOV_GvEv:
2908             break;
2909         case OP_LEA:
2910             *ptr = OP_MOV_GvEv;
2911             break;
2912         default:
2913             RELEASE_ASSERT_NOT_REACHED();
2914         }
2915     }
2916
2917     static void replaceWithAddressComputation(void* instructionStart)
2918     {
2919         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2920 #if CPU(X86_64)
2921         if ((*ptr & ~15) == PRE_REX)
2922             ptr++;
2923 #endif
2924         switch (*ptr) {
2925         case OP_MOV_GvEv:
2926             *ptr = OP_LEA;
2927             break;
2928         case OP_LEA:
2929             break;
2930         default:
2931             RELEASE_ASSERT_NOT_REACHED();
2932         }
2933     }
2934
2935     static unsigned getCallReturnOffset(AssemblerLabel call)
2936     {
2937         ASSERT(call.isSet());
2938         return call.m_offset;
2939     }
2940
2941     static void* getRelocatedAddress(void* code, AssemblerLabel label)
2942     {
2943         ASSERT(label.isSet());
2944         return reinterpret_cast<void*>(reinterpret_cast<ptrdiff_t>(code) + label.m_offset);
2945     }
2946
2947     static int getDifferenceBetweenLabels(AssemblerLabel a, AssemblerLabel b)
2948     {
2949         return b.m_offset - a.m_offset;
2950     }
2951
2952     unsigned debugOffset() { return m_formatter.debugOffset(); }
2953
2954     void nop()
2955     {
2956         m_formatter.oneByteOp(OP_NOP);
2957     }
2958
2959     static void fillNops(void* base, size_t size, bool isCopyingToExecutableMemory)
2960     {
2961         UNUSED_PARAM(isCopyingToExecutableMemory);
2962 #if CPU(X86_64)
2963         static const uint8_t nops[10][10] = {
2964             // nop
2965             {0x90},
2966             // xchg %ax,%ax
2967             {0x66, 0x90},
2968             // nopl (%[re]ax)
2969             {0x0f, 0x1f, 0x00},
2970             // nopl 8(%[re]ax)
2971             {0x0f, 0x1f, 0x40, 0x08},
2972             // nopl 8(%[re]ax,%[re]ax,1)
2973             {0x0f, 0x1f, 0x44, 0x00, 0x08},
2974             // nopw 8(%[re]ax,%[re]ax,1)
2975             {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x08},
2976             // nopl 512(%[re]ax)
2977             {0x0f, 0x1f, 0x80, 0x00, 0x02, 0x00, 0x00},
2978             // nopl 512(%[re]ax,%[re]ax,1)
2979             {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00},
2980             // nopw 512(%[re]ax,%[re]ax,1)
2981             {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00},
2982             // nopw %cs:512(%[re]ax,%[re]ax,1)
2983             {0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00}
2984         };
2985
2986         uint8_t* where = reinterpret_cast<uint8_t*>(base);
2987         while (size) {
2988             unsigned nopSize = static_cast<unsigned>(std::min<size_t>(size, 15));
2989             unsigned numPrefixes = nopSize <= 10 ? 0 : nopSize - 10;
2990             for (unsigned i = 0; i != numPrefixes; ++i)
2991                 *where++ = 0x66;
2992
2993             unsigned nopRest = nopSize - numPrefixes;
2994             for (unsigned i = 0; i != nopRest; ++i)
2995                 *where++ = nops[nopRest-1][i];
2996
2997             size -= nopSize;
2998         }
2999 #else
3000         memset(base, OP_NOP, size);
3001 #endif
3002     }
3003
3004     // This is a no-op on x86
3005     ALWAYS_INLINE static void cacheFlush(void*, size_t) { }
3006
3007 private:
3008
3009     static void setPointer(void* where, void* value)
3010     {
3011         reinterpret_cast<void**>(where)[-1] = value;
3012     }
3013
3014     static void setInt32(void* where, int32_t value)
3015     {
3016         reinterpret_cast<int32_t*>(where)[-1] = value;
3017     }
3018
3019     static void setInt8(void* where, int8_t value)
3020     {
3021         reinterpret_cast<int8_t*>(where)[-1] = value;
3022     }
3023
3024     static void setRel32(void* from, void* to)
3025     {
3026         intptr_t offset = reinterpret_cast<intptr_t>(to) - reinterpret_cast<intptr_t>(from);
3027         ASSERT(offset == static_cast<int32_t>(offset));
3028
3029         setInt32(from, offset);
3030     }
3031
3032     class X86InstructionFormatter {
3033         static const int maxInstructionSize = 16;
3034
3035     public:
3036         enum ModRmMode {
3037             ModRmMemoryNoDisp = 0,
3038             ModRmMemoryDisp8 = 1 << 6,
3039             ModRmMemoryDisp32 = 2 << 6,
3040             ModRmRegister = 3 << 6,
3041         };
3042
3043         // Legacy prefix bytes:
3044         //
3045         // These are emmitted prior to the instruction.
3046
3047         void prefix(OneByteOpcodeID pre)
3048         {
3049             m_buffer.putByte(pre);
3050         }
3051
3052 #if CPU(X86_64)
3053         // Byte operand register spl & above require a REX prefix (to prevent the 'H' registers be accessed).
3054         static bool byteRegRequiresRex(int reg)
3055         {
3056             static_assert(X86Registers::esp == 4, "Necessary condition for OR-masking");
3057             return (reg >= X86Registers::esp);
3058         }
3059         static bool byteRegRequiresRex(int a, int b)
3060         {
3061             return byteRegRequiresRex(a | b);
3062         }
3063
3064         // Registers r8 & above require a REX prefixe.
3065         static bool regRequiresRex(int reg)
3066         {
3067             static_assert(X86Registers::r8 == 8, "Necessary condition for OR-masking");
3068             return (reg >= X86Registers::r8);
3069         }
3070         static bool regRequiresRex(int a, int b)
3071         {
3072             return regRequiresRex(a | b);
3073         }
3074         static bool regRequiresRex(int a, int b, int c)
3075         {
3076             return regRequiresRex(a | b | c);
3077         }
3078 #else
3079         static bool byteRegRequiresRex(int) { return false; }
3080         static bool byteRegRequiresRex(int, int) { return false; }
3081         static bool regRequiresRex(int) { return false; }
3082         static bool regRequiresRex(int, int) { return false; }
3083         static bool regRequiresRex(int, int, int) { return false; }
3084 #endif
3085
3086         class SingleInstructionBufferWriter : public AssemblerBuffer::LocalWriter {
3087         public:
3088             SingleInstructionBufferWriter(AssemblerBuffer& buffer)
3089                 : AssemblerBuffer::LocalWriter(buffer, maxInstructionSize)
3090             {
3091             }
3092
3093             // Internals; ModRm and REX formatters.
3094
3095             static constexpr RegisterID noBase = X86Registers::ebp;
3096             static constexpr RegisterID hasSib = X86Registers::esp;
3097             static constexpr RegisterID noIndex = X86Registers::esp;
3098
3099 #if CPU(X86_64)
3100             static constexpr RegisterID noBase2 = X86Registers::r13;
3101             static constexpr RegisterID hasSib2 = X86Registers::r12;
3102
3103             // Format a REX prefix byte.
3104             ALWAYS_INLINE void emitRex(bool w, int r, int x, int b)
3105             {
3106                 ASSERT(r >= 0);
3107                 ASSERT(x >= 0);
3108                 ASSERT(b >= 0);
3109                 putByteUnchecked(PRE_REX | ((int)w << 3) | ((r>>3)<<2) | ((x>>3)<<1) | (b>>3));
3110             }
3111
3112             // Used to plant a REX byte with REX.w set (for 64-bit operations).
3113             ALWAYS_INLINE void emitRexW(int r, int x, int b)
3114             {
3115                 emitRex(true, r, x, b);
3116             }
3117
3118             // Used for operations with byte operands - use byteRegRequiresRex() to check register operands,
3119             // regRequiresRex() to check other registers (i.e. address base & index).
3120             ALWAYS_INLINE void emitRexIf(bool condition, int r, int x, int b)
3121             {
3122                 if (condition)
3123                     emitRex(false, r, x, b);
3124             }
3125
3126             // Used for word sized operations, will plant a REX prefix if necessary (if any register is r8 or above).
3127             ALWAYS_INLINE void emitRexIfNeeded(int r, int x, int b)
3128             {
3129                 emitRexIf(regRequiresRex(r, x, b), r, x, b);
3130             }
3131 #else
3132             // No REX prefix bytes on 32-bit x86.
3133             ALWAYS_INLINE void emitRexIf(bool, int, int, int) { }
3134             ALWAYS_INLINE void emitRexIfNeeded(int, int, int) { }
3135 #endif
3136
3137             ALWAYS_INLINE void putModRm(ModRmMode mode, int reg, RegisterID rm)
3138             {
3139                 putByteUnchecked(mode | ((reg & 7) << 3) | (rm & 7));
3140             }
3141
3142             ALWAYS_INLINE void putModRmSib(ModRmMode mode, int reg, RegisterID base, RegisterID index, int scale)
3143             {
3144                 ASSERT(mode != ModRmRegister);
3145
3146                 putModRm(mode, reg, hasSib);
3147                 putByteUnchecked((scale << 6) | ((index & 7) << 3) | (base & 7));
3148             }
3149
3150             ALWAYS_INLINE void registerModRM(int reg, RegisterID rm)
3151             {
3152                 putModRm(ModRmRegister, reg, rm);
3153             }
3154
3155             ALWAYS_INLINE void memoryModRM(int reg, RegisterID base, int offset)
3156             {
3157                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3158 #if CPU(X86_64)
3159                 if ((base == hasSib) || (base == hasSib2)) {
3160 #else
3161                 if (base == hasSib) {
3162 #endif
3163                     if (!offset) // No need to check if the base is noBase, since we know it is hasSib!
3164                         putModRmSib(ModRmMemoryNoDisp, reg, base, noIndex, 0);
3165                     else if (CAN_SIGN_EXTEND_8_32(offset)) {
3166                         putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
3167                         putByteUnchecked(offset);
3168                     } else {
3169                         putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
3170                         putIntUnchecked(offset);
3171                     }
3172                 } else {
3173 #if CPU(X86_64)
3174                     if (!offset && (base != noBase) && (base != noBase2))
3175 #else
3176                     if (!offset && (base != noBase))
3177 #endif
3178                         putModRm(ModRmMemoryNoDisp, reg, base);
3179                     else if (CAN_SIGN_EXTEND_8_32(offset)) {
3180                         putModRm(ModRmMemoryDisp8, reg, base);
3181                         putByteUnchecked(offset);
3182                     } else {
3183                         putModRm(ModRmMemoryDisp32, reg, base);
3184                         putIntUnchecked(offset);
3185                     }
3186                 }
3187             }
3188
3189             ALWAYS_INLINE void memoryModRM_disp8(int reg, RegisterID base, int offset)
3190             {
3191                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3192                 ASSERT(CAN_SIGN_EXTEND_8_32(offset));
3193 #if CPU(X86_64)
3194                 if ((base == hasSib) || (base == hasSib2)) {
3195 #else
3196                 if (base == hasSib) {
3197 #endif
3198                     putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
3199                     putByteUnchecked(offset);
3200                 } else {
3201                     putModRm(ModRmMemoryDisp8, reg, base);
3202                     putByteUnchecked(offset);
3203                 }
3204             }
3205
3206             ALWAYS_INLINE void memoryModRM_disp32(int reg, RegisterID base, int offset)
3207             {
3208                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3209 #if CPU(X86_64)
3210                 if ((base == hasSib) || (base == hasSib2)) {
3211 #else
3212                 if (base == hasSib) {
3213 #endif
3214                     putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
3215                     putIntUnchecked(offset);
3216                 } else {
3217                     putModRm(ModRmMemoryDisp32, reg, base);
3218                     putIntUnchecked(offset);
3219                 }
3220             }
3221
3222             ALWAYS_INLINE void memoryModRM(int reg, RegisterID base, RegisterID index, int scale, int offset)
3223             {
3224                 ASSERT(index != noIndex);
3225
3226 #if CPU(X86_64)
3227                 if (!offset && (base != noBase) && (base != noBase2))
3228 #else
3229                 if (!offset && (base != noBase))
3230 #endif
3231                     putModRmSib(ModRmMemoryNoDisp, reg, base, index, scale);
3232                 else if (CAN_SIGN_EXTEND_8_32(offset)) {
3233                     putModRmSib(ModRmMemoryDisp8, reg, base, index, scale);
3234                     putByteUnchecked(offset);
3235                 } else {
3236                     putModRmSib(ModRmMemoryDisp32, reg, base, index, scale);
3237                     putIntUnchecked(offset);
3238                 }
3239             }
3240
3241 #if !CPU(X86_64)
3242             ALWAYS_INLINE void memoryModRM(int reg, const void* address)
3243             {
3244                 // noBase + ModRmMemoryNoDisp means noBase + ModRmMemoryDisp32!
3245                 putModRm(ModRmMemoryNoDisp, reg, noBase);
3246                 putIntUnchecked(reinterpret_cast<int32_t>(address));
3247             }
3248 #endif
3249             ALWAYS_INLINE void twoBytesVex(OneByteOpcodeID simdPrefix, RegisterID inOpReg, RegisterID r)
3250             {
3251                 putByteUnchecked(VexPrefix::TwoBytes);
3252
3253                 uint8_t secondByte = vexEncodeSimdPrefix(simdPrefix);
3254                 secondByte |= (~inOpReg & 0xf) << 3;
3255                 secondByte |= !regRequiresRex(r) << 7;
3256                 putByteUnchecked(secondByte);
3257             }
3258
3259             ALWAYS_INLINE void threeBytesVexNds(OneByteOpcodeID simdPrefix, VexImpliedBytes impliedBytes, RegisterID r, RegisterID inOpReg, RegisterID x, RegisterID b)
3260             {
3261                 putByteUnchecked(VexPrefix::ThreeBytes);
3262
3263                 uint8_t secondByte = static_cast<uint8_t>(impliedBytes);
3264                 secondByte |= !regRequiresRex(r) << 7;
3265                 secondByte |= !regRequiresRex(x) << 6;
3266                 secondByte |= !regRequiresRex(b) << 5;
3267                 putByteUnchecked(secondByte);
3268
3269                 uint8_t thirdByte = vexEncodeSimdPrefix(simdPrefix);
3270                 thirdByte |= (~inOpReg & 0xf) << 3;
3271                 putByteUnchecked(thirdByte);
3272             }
3273
3274             ALWAYS_INLINE void threeBytesVexNds(OneByteOpcodeID simdPrefix, VexImpliedBytes impliedBytes, RegisterID r, RegisterID inOpReg, RegisterID b)
3275             {
3276                 putByteUnchecked(VexPrefix::ThreeBytes);
3277
3278                 uint8_t secondByte = static_cast<uint8_t>(impliedBytes);
3279                 secondByte |= !regRequiresRex(r) << 7;
3280                 secondByte |= 1 << 6; // REX.X
3281                 secondByte |= !regRequiresRex(b) << 5;
3282                 putByteUnchecked(secondByte);
3283
3284                 uint8_t thirdByte = vexEncodeSimdPrefix(simdPrefix);
3285                 thirdByte |= (~inOpReg & 0xf) << 3;
3286                 putByteUnchecked(thirdByte);
3287             }
3288         private:
3289             uint8_t vexEncodeSimdPrefix(OneByteOpcodeID simdPrefix)
3290             {
3291                 switch (simdPrefix) {
3292                 case 0x66:
3293                     return 1;
3294                 case 0xF3:
3295                     return 2;
3296                 case 0xF2:
3297                     return 3;
3298                 default:
3299                     RELEASE_ASSERT_NOT_REACHED();
3300                 }
3301                 return 0;
3302             }
3303
3304         };
3305
3306         // Word-sized operands / no operand instruction formatters.
3307         //
3308         // In addition to the opcode, the following operand permutations are supported:
3309         //   * None - instruction takes no operands.
3310         //   * One register - the low three bits of the RegisterID are added into the opcode.
3311         //   * Two registers - encode a register form ModRm (for all ModRm formats, the reg field is passed first, and a GroupOpcodeID may be passed in its place).
3312         //   * Three argument ModRM - a register, and a register and an offset describing a memory operand.
3313         //   * Five argument ModRM - a register, and a base register, an index, scale, and offset describing a memory operand.
3314         //
3315         // For 32-bit x86 targets, the address operand may also be provided as a void*.
3316         // On 64-bit targets REX prefixes will be planted as necessary, where high numbered registers are used.
3317         //
3318         // The twoByteOp methods plant two-byte Intel instructions sequences (first opcode byte 0x0F).
3319
3320         void oneByteOp(OneByteOpcodeID opcode)
3321         {
3322             SingleInstructionBufferWriter writer(m_buffer);
3323             writer.putByteUnchecked(opcode);
3324         }
3325
3326         void oneByteOp(OneByteOpcodeID opcode, RegisterID reg)
3327         {
3328             SingleInstructionBufferWriter writer(m_buffer);
3329             writer.emitRexIfNeeded(0, 0, reg);
3330             writer.putByteUnchecked(opcode + (reg & 7));
3331         }
3332
3333         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID rm)
3334         {
3335             SingleInstructionBufferWriter writer(m_buffer);
3336             writer.emitRexIfNeeded(reg, 0, rm);
3337             writer.putByteUnchecked(opcode);
3338             writer.registerModRM(reg, rm);
3339         }
3340
3341         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3342         {
3343             SingleInstructionBufferWriter writer(m_buffer);
3344             writer.emitRexIfNeeded(reg, 0, base);
3345             writer.putByteUnchecked(opcode);
3346             writer.memoryModRM(reg, base, offset);
3347         }
3348
3349         void oneByteOp_disp32(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3350         {
3351             SingleInstructionBufferWriter writer(m_buffer);
3352             writer.emitRexIfNeeded(reg, 0, base);
3353             writer.putByteUnchecked(opcode);
3354             writer.memoryModRM_disp32(reg, base, offset);
3355         }
3356
3357         void oneByteOp_disp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3358         {
3359             SingleInstructionBufferWriter writer(m_buffer);
3360             writer.emitRexIfNeeded(reg, 0, base);
3361             writer.putByteUnchecked(opcode);
3362             writer.memoryModRM_disp8(reg, base, offset);
3363         }
3364
3365         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3366         {
3367             SingleInstructionBufferWriter writer(m_buffer);
3368             writer.emitRexIfNeeded(reg, index, base);
3369             writer.putByteUnchecked(opcode);
3370             writer.memoryModRM(reg, base, index, scale, offset);
3371         }
3372
3373 #if !CPU(X86_64)
3374         void oneByteOp(OneByteOpcodeID opcode, int reg, const void* address)
3375         {
3376             SingleInstructionBufferWriter writer(m_buffer);
3377             writer.putByteUnchecked(opcode);
3378             writer.memoryModRM(reg, address);
3379         }
3380 #endif