Source/JavaScriptCore/assembler/X86Assembler.h

   1 /*
   2  * Copyright (C) 2008, 2012, 2013 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 "JITCompilationEffort.h"
  33 #include <limits.h>
  34 #include <stdint.h>
  35 #include <wtf/Assertions.h>
  36 #include <wtf/Vector.h>
  37
  38 #if USE(MASM_PROBE)
  39 #include <xmmintrin.h>
  40 #endif
  41
  42 namespace JSC {
  43
  44 inline bool CAN_SIGN_EXTEND_8_32(int32_t value) { return value == (int32_t)(signed char)value; }
  45
  46 namespace X86Registers {
  47     typedef enum {
  48         eax,
  49         ecx,
  50         edx,
  51         ebx,
  52         esp,
  53         ebp,
  54         esi,
  55         edi,
  56
  57 #if CPU(X86_64)
  58         r8,
  59         r9,
  60         r10,
  61         r11,
  62         r12,
  63         r13,
  64         r14,
  65         r15,
  66 #endif
  67     } RegisterID;
  68
  69     typedef enum {
  70         xmm0,
  71         xmm1,
  72         xmm2,
  73         xmm3,
  74         xmm4,
  75         xmm5,
  76         xmm6,
  77         xmm7,
  78
  79 #if CPU(X86_64)
  80         xmm8,
  81         xmm9,
  82         xmm10,
  83         xmm11,
  84         xmm12,
  85         xmm13,
  86         xmm14,
  87         xmm15,
  88 #endif
  89     } XMMRegisterID;
  90
  91 #if USE(MASM_PROBE)
  92     #define FOR_EACH_CPU_REGISTER(V) \
  93         FOR_EACH_CPU_GPREGISTER(V) \
  94         FOR_EACH_CPU_SPECIAL_REGISTER(V) \
  95         FOR_EACH_CPU_FPREGISTER(V)
  96
  97     #define FOR_EACH_CPU_GPREGISTER(V) \
  98         V(void*, eax) \
  99         V(void*, ebx) \
 100         V(void*, ecx) \
 101         V(void*, edx) \
 102         V(void*, esi) \
 103         V(void*, edi) \
 104         V(void*, ebp) \
 105         V(void*, esp) \
 106         FOR_EACH_X86_64_CPU_GPREGISTER(V)
 107
 108     #define FOR_EACH_CPU_SPECIAL_REGISTER(V) \
 109         V(void*, eip) \
 110         V(void*, eflags) \
 111
 112     #define FOR_EACH_CPU_FPREGISTER(V) \
 113         V(__m128, xmm0) \
 114         V(__m128, xmm1) \
 115         V(__m128, xmm2) \
 116         V(__m128, xmm3) \
 117         V(__m128, xmm4) \
 118         V(__m128, xmm5) \
 119         V(__m128, xmm6) \
 120         V(__m128, xmm7)
 121
 122 #if CPU(X86)
 123     #define FOR_EACH_X86_64_CPU_GPREGISTER(V) // Nothing to add.
 124 #elif CPU(X86_64)
 125     #define FOR_EACH_X86_64_CPU_GPREGISTER(V) \
 126         V(void*, r8) \
 127         V(void*, r9) \
 128         V(void*, r10) \
 129         V(void*, r11) \
 130         V(void*, r12) \
 131         V(void*, r13) \
 132         V(void*, r14) \
 133         V(void*, r15)
 134 #endif // CPU(X86_64)
 135 #endif // USE(MASM_PROBE)
 136 }
 137
 138 class X86Assembler {
 139 public:
 140     typedef X86Registers::RegisterID RegisterID;
 141
 142     static RegisterID firstRegister() { return X86Registers::eax; }
 143     static RegisterID lastRegister()
 144     {
 145 #if CPU(X86_64)
 146         return X86Registers::r15;
 147 #else
 148         return X86Registers::edi;
 149 #endif
 150     }
 151
 152     typedef X86Registers::XMMRegisterID XMMRegisterID;
 153     typedef XMMRegisterID FPRegisterID;
 154
 155     static FPRegisterID firstFPRegister() { return X86Registers::xmm0; }
 156     static FPRegisterID lastFPRegister()
 157     {
 158 #if CPU(X86_64)
 159         return X86Registers::xmm15;
 160 #else
 161         return X86Registers::xmm7;
 162 #endif
 163     }
 164
 165     typedef enum {
 166         ConditionO,
 167         ConditionNO,
 168         ConditionB,
 169         ConditionAE,
 170         ConditionE,
 171         ConditionNE,
 172         ConditionBE,
 173         ConditionA,
 174         ConditionS,
 175         ConditionNS,
 176         ConditionP,
 177         ConditionNP,
 178         ConditionL,
 179         ConditionGE,
 180         ConditionLE,
 181         ConditionG,
 182
 183         ConditionC  = ConditionB,
 184         ConditionNC = ConditionAE,
 185     } Condition;
 186
 187 private:
 188     typedef enum {
 189         OP_ADD_EvGv                     = 0x01,
 190         OP_ADD_GvEv                     = 0x03,
 191         OP_OR_EvGv                      = 0x09,
 192         OP_OR_GvEv                      = 0x0B,
 193         OP_2BYTE_ESCAPE                 = 0x0F,
 194         OP_AND_EvGv                     = 0x21,
 195         OP_AND_GvEv                     = 0x23,
 196         OP_SUB_EvGv                     = 0x29,
 197         OP_SUB_GvEv                     = 0x2B,
 198         PRE_PREDICT_BRANCH_NOT_TAKEN    = 0x2E,
 199         OP_XOR_EvGv                     = 0x31,
 200         OP_XOR_GvEv                     = 0x33,
 201         OP_CMP_EvGv                     = 0x39,
 202         OP_CMP_GvEv                     = 0x3B,
 203 #if CPU(X86_64)
 204         PRE_REX                         = 0x40,
 205 #endif
 206         OP_PUSH_EAX                     = 0x50,
 207         OP_POP_EAX                      = 0x58,
 208 #if CPU(X86_64)
 209         OP_MOVSXD_GvEv                  = 0x63,
 210 #endif
 211         PRE_OPERAND_SIZE                = 0x66,
 212         PRE_SSE_66                      = 0x66,
 213         OP_PUSH_Iz                      = 0x68,
 214         OP_IMUL_GvEvIz                  = 0x69,
 215         OP_GROUP1_EbIb                  = 0x80,
 216         OP_GROUP1_EvIz                  = 0x81,
 217         OP_GROUP1_EvIb                  = 0x83,
 218         OP_TEST_EbGb                    = 0x84,
 219         OP_TEST_EvGv                    = 0x85,
 220         OP_XCHG_EvGv                    = 0x87,
 221         OP_MOV_EbGb                     = 0x88,
 222         OP_MOV_EvGv                     = 0x89,
 223         OP_MOV_GvEv                     = 0x8B,
 224         OP_LEA                          = 0x8D,
 225         OP_GROUP1A_Ev                   = 0x8F,
 226         OP_NOP                          = 0x90,
 227         OP_XCHG_EAX                     = 0x90,
 228         OP_CDQ                          = 0x99,
 229         OP_MOV_EAXOv                    = 0xA1,
 230         OP_MOV_OvEAX                    = 0xA3,
 231         OP_MOV_EAXIv                    = 0xB8,
 232         OP_GROUP2_EvIb                  = 0xC1,
 233         OP_RET                          = 0xC3,
 234         OP_GROUP11_EvIb                 = 0xC6,
 235         OP_GROUP11_EvIz                 = 0xC7,
 236         OP_INT3                         = 0xCC,
 237         OP_GROUP2_Ev1                   = 0xD1,
 238         OP_GROUP2_EvCL                  = 0xD3,
 239         OP_ESCAPE_DD                    = 0xDD,
 240         OP_CALL_rel32                   = 0xE8,
 241         OP_JMP_rel32                    = 0xE9,
 242         PRE_SSE_F2                      = 0xF2,
 243         PRE_SSE_F3                      = 0xF3,
 244         OP_HLT                          = 0xF4,
 245         OP_GROUP3_EbIb                  = 0xF6,
 246         OP_GROUP3_Ev                    = 0xF7,
 247         OP_GROUP3_EvIz                  = 0xF7, // OP_GROUP3_Ev has an immediate, when instruction is a test.
 248         OP_GROUP5_Ev                    = 0xFF,
 249     } OneByteOpcodeID;
 250
 251     typedef enum {
 252         OP2_MOVSD_VsdWsd    = 0x10,
 253         OP2_MOVSD_WsdVsd    = 0x11,
 254         OP2_MOVSS_VsdWsd    = 0x10,
 255         OP2_MOVSS_WsdVsd    = 0x11,
 256         OP2_CVTSI2SD_VsdEd  = 0x2A,
 257         OP2_CVTTSD2SI_GdWsd = 0x2C,
 258         OP2_UCOMISD_VsdWsd  = 0x2E,
 259         OP2_ADDSD_VsdWsd    = 0x58,
 260         OP2_MULSD_VsdWsd    = 0x59,
 261         OP2_CVTSD2SS_VsdWsd = 0x5A,
 262         OP2_CVTSS2SD_VsdWsd = 0x5A,
 263         OP2_SUBSD_VsdWsd    = 0x5C,
 264         OP2_DIVSD_VsdWsd    = 0x5E,
 265         OP2_SQRTSD_VsdWsd   = 0x51,
 266         OP2_ANDNPD_VpdWpd   = 0x55,
 267         OP2_XORPD_VpdWpd    = 0x57,
 268         OP2_MOVD_VdEd       = 0x6E,
 269         OP2_MOVD_EdVd       = 0x7E,
 270         OP2_JCC_rel32       = 0x80,
 271         OP_SETCC            = 0x90,
 272         OP2_3BYTE_ESCAPE    = 0xAE,
 273         OP2_IMUL_GvEv       = 0xAF,
 274         OP2_MOVZX_GvEb      = 0xB6,
 275         OP2_MOVSX_GvEb      = 0xBE,
 276         OP2_MOVZX_GvEw      = 0xB7,
 277         OP2_MOVSX_GvEw      = 0xBF,
 278         OP2_PEXTRW_GdUdIb   = 0xC5,
 279         OP2_PSLLQ_UdqIb     = 0x73,
 280         OP2_PSRLQ_UdqIb     = 0x73,
 281         OP2_POR_VdqWdq      = 0XEB,
 282     } TwoByteOpcodeID;
 283
 284     typedef enum {
 285         OP3_MFENCE          = 0xF0,
 286     } ThreeByteOpcodeID;
 287
 288     TwoByteOpcodeID jccRel32(Condition cond)
 289     {
 290         return (TwoByteOpcodeID)(OP2_JCC_rel32 + cond);
 291     }
 292
 293     TwoByteOpcodeID setccOpcode(Condition cond)
 294     {
 295         return (TwoByteOpcodeID)(OP_SETCC + cond);
 296     }
 297
 298     typedef enum {
 299         GROUP1_OP_ADD = 0,
 300         GROUP1_OP_OR  = 1,
 301         GROUP1_OP_ADC = 2,
 302         GROUP1_OP_AND = 4,
 303         GROUP1_OP_SUB = 5,
 304         GROUP1_OP_XOR = 6,
 305         GROUP1_OP_CMP = 7,
 306
 307         GROUP1A_OP_POP = 0,
 308
 309         GROUP2_OP_ROL = 0,
 310         GROUP2_OP_ROR = 1,
 311         GROUP2_OP_RCL = 2,
 312         GROUP2_OP_RCR = 3,
 313
 314         GROUP2_OP_SHL = 4,
 315         GROUP2_OP_SHR = 5,
 316         GROUP2_OP_SAR = 7,
 317
 318         GROUP3_OP_TEST = 0,
 319         GROUP3_OP_NOT  = 2,
 320         GROUP3_OP_NEG  = 3,
 321         GROUP3_OP_IDIV = 7,
 322
 323         GROUP5_OP_CALLN = 2,
 324         GROUP5_OP_JMPN  = 4,
 325         GROUP5_OP_PUSH  = 6,
 326
 327         GROUP11_MOV = 0,
 328
 329         GROUP14_OP_PSLLQ = 6,
 330         GROUP14_OP_PSRLQ = 2,
 331
 332         ESCAPE_DD_FSTP_doubleReal = 3,
 333     } GroupOpcodeID;
 334
 335     class X86InstructionFormatter;
 336 public:
 337
 338     X86Assembler()
 339         : m_indexOfLastWatchpoint(INT_MIN)
 340         , m_indexOfTailOfLastWatchpoint(INT_MIN)
 341     {
 342     }
 343
 344     AssemblerBuffer& buffer() { return m_formatter.m_buffer; }
 345
 346     // Stack operations:
 347
 348     void push_r(RegisterID reg)
 349     {
 350         m_formatter.oneByteOp(OP_PUSH_EAX, reg);
 351     }
 352
 353     void pop_r(RegisterID reg)
 354     {
 355         m_formatter.oneByteOp(OP_POP_EAX, reg);
 356     }
 357
 358     void push_i32(int imm)
 359     {
 360         m_formatter.oneByteOp(OP_PUSH_Iz);
 361         m_formatter.immediate32(imm);
 362     }
 363
 364     void push_m(int offset, RegisterID base)
 365     {
 366         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_PUSH, base, offset);
 367     }
 368
 369     void pop_m(int offset, RegisterID base)
 370     {
 371         m_formatter.oneByteOp(OP_GROUP1A_Ev, GROUP1A_OP_POP, base, offset);
 372     }
 373
 374     // Arithmetic operations:
 375
 376 #if !CPU(X86_64)
 377     void adcl_im(int imm, const void* addr)
 378     {
 379         if (CAN_SIGN_EXTEND_8_32(imm)) {
 380             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADC, addr);
 381             m_formatter.immediate8(imm);
 382         } else {
 383             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADC, addr);
 384             m_formatter.immediate32(imm);
 385         }
 386     }
 387 #endif
 388
 389     void addl_rr(RegisterID src, RegisterID dst)
 390     {
 391         m_formatter.oneByteOp(OP_ADD_EvGv, src, dst);
 392     }
 393
 394     void addl_mr(int offset, RegisterID base, RegisterID dst)
 395     {
 396         m_formatter.oneByteOp(OP_ADD_GvEv, dst, base, offset);
 397     }
 398
 399 #if !CPU(X86_64)
 400     void addl_mr(const void* addr, RegisterID dst)
 401     {
 402         m_formatter.oneByteOp(OP_ADD_GvEv, dst, addr);
 403     }
 404 #endif
 405
 406     void addl_rm(RegisterID src, int offset, RegisterID base)
 407     {
 408         m_formatter.oneByteOp(OP_ADD_EvGv, src, base, offset);
 409     }
 410
 411     void addl_ir(int imm, RegisterID dst)
 412     {
 413         if (CAN_SIGN_EXTEND_8_32(imm)) {
 414             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, dst);
 415             m_formatter.immediate8(imm);
 416         } else {
 417             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, dst);
 418             m_formatter.immediate32(imm);
 419         }
 420     }
 421
 422     void addl_im(int imm, int offset, RegisterID base)
 423     {
 424         if (CAN_SIGN_EXTEND_8_32(imm)) {
 425             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, offset);
 426             m_formatter.immediate8(imm);
 427         } else {
 428             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, offset);
 429             m_formatter.immediate32(imm);
 430         }
 431     }
 432
 433 #if CPU(X86_64)
 434     void addq_rr(RegisterID src, RegisterID dst)
 435     {
 436         m_formatter.oneByteOp64(OP_ADD_EvGv, src, dst);
 437     }
 438
 439     void addq_mr(int offset, RegisterID base, RegisterID dst)
 440     {
 441         m_formatter.oneByteOp64(OP_ADD_GvEv, dst, base, offset);
 442     }
 443
 444     void addq_ir(int imm, RegisterID dst)
 445     {
 446         if (CAN_SIGN_EXTEND_8_32(imm)) {
 447             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_ADD, dst);
 448             m_formatter.immediate8(imm);
 449         } else {
 450             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_ADD, dst);
 451             m_formatter.immediate32(imm);
 452         }
 453     }
 454
 455     void addq_im(int imm, int offset, RegisterID base)
 456     {
 457         if (CAN_SIGN_EXTEND_8_32(imm)) {
 458             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_ADD, base, offset);
 459             m_formatter.immediate8(imm);
 460         } else {
 461             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_ADD, base, offset);
 462             m_formatter.immediate32(imm);
 463         }
 464     }
 465 #else
 466     void addl_im(int imm, const void* addr)
 467     {
 468         if (CAN_SIGN_EXTEND_8_32(imm)) {
 469             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_ADD, addr);
 470             m_formatter.immediate8(imm);
 471         } else {
 472             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_ADD, addr);
 473             m_formatter.immediate32(imm);
 474         }
 475     }
 476 #endif
 477
 478     void andl_rr(RegisterID src, RegisterID dst)
 479     {
 480         m_formatter.oneByteOp(OP_AND_EvGv, src, dst);
 481     }
 482
 483     void andl_mr(int offset, RegisterID base, RegisterID dst)
 484     {
 485         m_formatter.oneByteOp(OP_AND_GvEv, dst, base, offset);
 486     }
 487
 488     void andl_rm(RegisterID src, int offset, RegisterID base)
 489     {
 490         m_formatter.oneByteOp(OP_AND_EvGv, src, base, offset);
 491     }
 492
 493     void andl_ir(int imm, RegisterID dst)
 494     {
 495         if (CAN_SIGN_EXTEND_8_32(imm)) {
 496             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, dst);
 497             m_formatter.immediate8(imm);
 498         } else {
 499             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, dst);
 500             m_formatter.immediate32(imm);
 501         }
 502     }
 503
 504     void andl_im(int imm, int offset, RegisterID base)
 505     {
 506         if (CAN_SIGN_EXTEND_8_32(imm)) {
 507             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, base, offset);
 508             m_formatter.immediate8(imm);
 509         } else {
 510             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, base, offset);
 511             m_formatter.immediate32(imm);
 512         }
 513     }
 514
 515 #if CPU(X86_64)
 516     void andq_rr(RegisterID src, RegisterID dst)
 517     {
 518         m_formatter.oneByteOp64(OP_AND_EvGv, src, dst);
 519     }
 520
 521     void andq_ir(int imm, RegisterID dst)
 522     {
 523         if (CAN_SIGN_EXTEND_8_32(imm)) {
 524             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_AND, dst);
 525             m_formatter.immediate8(imm);
 526         } else {
 527             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_AND, dst);
 528             m_formatter.immediate32(imm);
 529         }
 530     }
 531 #else
 532     void andl_im(int imm, const void* addr)
 533     {
 534         if (CAN_SIGN_EXTEND_8_32(imm)) {
 535             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_AND, addr);
 536             m_formatter.immediate8(imm);
 537         } else {
 538             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_AND, addr);
 539             m_formatter.immediate32(imm);
 540         }
 541     }
 542 #endif
 543
 544     void dec_r(RegisterID dst)
 545     {
 546         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP1_OP_OR, dst);
 547     }
 548
 549 #if CPU(X86_64)
 550     void decq_r(RegisterID dst)
 551     {
 552         m_formatter.oneByteOp64(OP_GROUP5_Ev, GROUP1_OP_OR, dst);
 553     }
 554 #endif // CPU(X86_64)
 555
 556     void inc_r(RegisterID dst)
 557     {
 558         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP1_OP_ADD, dst);
 559     }
 560
 561 #if CPU(X86_64)
 562     void incq_r(RegisterID dst)
 563     {
 564         m_formatter.oneByteOp64(OP_GROUP5_Ev, GROUP1_OP_ADD, dst);
 565     }
 566 #endif // CPU(X86_64)
 567
 568     void negl_r(RegisterID dst)
 569     {
 570         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NEG, dst);
 571     }
 572
 573 #if CPU(X86_64)
 574     void negq_r(RegisterID dst)
 575     {
 576         m_formatter.oneByteOp64(OP_GROUP3_Ev, GROUP3_OP_NEG, dst);
 577     }
 578 #endif
 579
 580     void negl_m(int offset, RegisterID base)
 581     {
 582         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NEG, base, offset);
 583     }
 584
 585     void notl_r(RegisterID dst)
 586     {
 587         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NOT, dst);
 588     }
 589
 590     void notl_m(int offset, RegisterID base)
 591     {
 592         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_NOT, base, offset);
 593     }
 594
 595     void orl_rr(RegisterID src, RegisterID dst)
 596     {
 597         m_formatter.oneByteOp(OP_OR_EvGv, src, dst);
 598     }
 599
 600     void orl_mr(int offset, RegisterID base, RegisterID dst)
 601     {
 602         m_formatter.oneByteOp(OP_OR_GvEv, dst, base, offset);
 603     }
 604
 605     void orl_rm(RegisterID src, int offset, RegisterID base)
 606     {
 607         m_formatter.oneByteOp(OP_OR_EvGv, src, base, offset);
 608     }
 609
 610     void orl_ir(int imm, RegisterID dst)
 611     {
 612         if (CAN_SIGN_EXTEND_8_32(imm)) {
 613             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, dst);
 614             m_formatter.immediate8(imm);
 615         } else {
 616             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, dst);
 617             m_formatter.immediate32(imm);
 618         }
 619     }
 620
 621     void orl_im(int imm, int offset, RegisterID base)
 622     {
 623         if (CAN_SIGN_EXTEND_8_32(imm)) {
 624             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, base, offset);
 625             m_formatter.immediate8(imm);
 626         } else {
 627             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, base, offset);
 628             m_formatter.immediate32(imm);
 629         }
 630     }
 631
 632 #if CPU(X86_64)
 633     void orq_rr(RegisterID src, RegisterID dst)
 634     {
 635         m_formatter.oneByteOp64(OP_OR_EvGv, src, dst);
 636     }
 637
 638     void orq_ir(int imm, RegisterID dst)
 639     {
 640         if (CAN_SIGN_EXTEND_8_32(imm)) {
 641             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_OR, dst);
 642             m_formatter.immediate8(imm);
 643         } else {
 644             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_OR, dst);
 645             m_formatter.immediate32(imm);
 646         }
 647     }
 648 #else
 649     void orl_im(int imm, const void* addr)
 650     {
 651         if (CAN_SIGN_EXTEND_8_32(imm)) {
 652             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_OR, addr);
 653             m_formatter.immediate8(imm);
 654         } else {
 655             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_OR, addr);
 656             m_formatter.immediate32(imm);
 657         }
 658     }
 659
 660     void orl_rm(RegisterID src, const void* addr)
 661     {
 662         m_formatter.oneByteOp(OP_OR_EvGv, src, addr);
 663     }
 664 #endif
 665
 666     void subl_rr(RegisterID src, RegisterID dst)
 667     {
 668         m_formatter.oneByteOp(OP_SUB_EvGv, src, dst);
 669     }
 670
 671     void subl_mr(int offset, RegisterID base, RegisterID dst)
 672     {
 673         m_formatter.oneByteOp(OP_SUB_GvEv, dst, base, offset);
 674     }
 675
 676     void subl_rm(RegisterID src, int offset, RegisterID base)
 677     {
 678         m_formatter.oneByteOp(OP_SUB_EvGv, src, base, offset);
 679     }
 680
 681     void subl_ir(int imm, RegisterID dst)
 682     {
 683         if (CAN_SIGN_EXTEND_8_32(imm)) {
 684             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, dst);
 685             m_formatter.immediate8(imm);
 686         } else {
 687             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, dst);
 688             m_formatter.immediate32(imm);
 689         }
 690     }
 691
 692     void subl_im(int imm, int offset, RegisterID base)
 693     {
 694         if (CAN_SIGN_EXTEND_8_32(imm)) {
 695             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, base, offset);
 696             m_formatter.immediate8(imm);
 697         } else {
 698             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, base, offset);
 699             m_formatter.immediate32(imm);
 700         }
 701     }
 702
 703 #if CPU(X86_64)
 704     void subq_rr(RegisterID src, RegisterID dst)
 705     {
 706         m_formatter.oneByteOp64(OP_SUB_EvGv, src, dst);
 707     }
 708
 709     void subq_ir(int imm, RegisterID dst)
 710     {
 711         if (CAN_SIGN_EXTEND_8_32(imm)) {
 712             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_SUB, dst);
 713             m_formatter.immediate8(imm);
 714         } else {
 715             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_SUB, dst);
 716             m_formatter.immediate32(imm);
 717         }
 718     }
 719 #else
 720     void subl_im(int imm, const void* addr)
 721     {
 722         if (CAN_SIGN_EXTEND_8_32(imm)) {
 723             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_SUB, addr);
 724             m_formatter.immediate8(imm);
 725         } else {
 726             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_SUB, addr);
 727             m_formatter.immediate32(imm);
 728         }
 729     }
 730 #endif
 731
 732     void xorl_rr(RegisterID src, RegisterID dst)
 733     {
 734         m_formatter.oneByteOp(OP_XOR_EvGv, src, dst);
 735     }
 736
 737     void xorl_mr(int offset, RegisterID base, RegisterID dst)
 738     {
 739         m_formatter.oneByteOp(OP_XOR_GvEv, dst, base, offset);
 740     }
 741
 742     void xorl_rm(RegisterID src, int offset, RegisterID base)
 743     {
 744         m_formatter.oneByteOp(OP_XOR_EvGv, src, base, offset);
 745     }
 746
 747     void xorl_im(int imm, int offset, RegisterID base)
 748     {
 749         if (CAN_SIGN_EXTEND_8_32(imm)) {
 750             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_XOR, base, offset);
 751             m_formatter.immediate8(imm);
 752         } else {
 753             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_XOR, base, offset);
 754             m_formatter.immediate32(imm);
 755         }
 756     }
 757
 758     void xorl_ir(int imm, RegisterID dst)
 759     {
 760         if (CAN_SIGN_EXTEND_8_32(imm)) {
 761             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_XOR, dst);
 762             m_formatter.immediate8(imm);
 763         } else {
 764             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_XOR, dst);
 765             m_formatter.immediate32(imm);
 766         }
 767     }
 768
 769 #if CPU(X86_64)
 770     void xorq_rr(RegisterID src, RegisterID dst)
 771     {
 772         m_formatter.oneByteOp64(OP_XOR_EvGv, src, dst);
 773     }
 774
 775     void xorq_ir(int imm, RegisterID dst)
 776     {
 777         if (CAN_SIGN_EXTEND_8_32(imm)) {
 778             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_XOR, dst);
 779             m_formatter.immediate8(imm);
 780         } else {
 781             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_XOR, dst);
 782             m_formatter.immediate32(imm);
 783         }
 784     }
 785
 786     void xorq_rm(RegisterID src, int offset, RegisterID base)
 787     {
 788         m_formatter.oneByteOp64(OP_XOR_EvGv, src, base, offset);
 789     }
 790
 791     void rorq_i8r(int imm, RegisterID dst)
 792     {
 793         if (imm == 1)
 794             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_ROR, dst);
 795         else {
 796             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_ROR, dst);
 797             m_formatter.immediate8(imm);
 798         }
 799     }
 800
 801 #endif
 802
 803     void sarl_i8r(int imm, RegisterID dst)
 804     {
 805         if (imm == 1)
 806             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SAR, dst);
 807         else {
 808             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SAR, dst);
 809             m_formatter.immediate8(imm);
 810         }
 811     }
 812
 813     void sarl_CLr(RegisterID dst)
 814     {
 815         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SAR, dst);
 816     }
 817
 818     void shrl_i8r(int imm, RegisterID dst)
 819     {
 820         if (imm == 1)
 821             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SHR, dst);
 822         else {
 823             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SHR, dst);
 824             m_formatter.immediate8(imm);
 825         }
 826     }
 827
 828     void shrl_CLr(RegisterID dst)
 829     {
 830         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SHR, dst);
 831     }
 832
 833     void shll_i8r(int imm, RegisterID dst)
 834     {
 835         if (imm == 1)
 836             m_formatter.oneByteOp(OP_GROUP2_Ev1, GROUP2_OP_SHL, dst);
 837         else {
 838             m_formatter.oneByteOp(OP_GROUP2_EvIb, GROUP2_OP_SHL, dst);
 839             m_formatter.immediate8(imm);
 840         }
 841     }
 842
 843     void shll_CLr(RegisterID dst)
 844     {
 845         m_formatter.oneByteOp(OP_GROUP2_EvCL, GROUP2_OP_SHL, dst);
 846     }
 847
 848 #if CPU(X86_64)
 849     void sarq_CLr(RegisterID dst)
 850     {
 851         m_formatter.oneByteOp64(OP_GROUP2_EvCL, GROUP2_OP_SAR, dst);
 852     }
 853
 854     void sarq_i8r(int imm, RegisterID dst)
 855     {
 856         if (imm == 1)
 857             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_SAR, dst);
 858         else {
 859             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_SAR, dst);
 860             m_formatter.immediate8(imm);
 861         }
 862     }
 863
 864     void shlq_i8r(int imm, RegisterID dst)
 865     {
 866         if (imm == 1)
 867             m_formatter.oneByteOp64(OP_GROUP2_Ev1, GROUP2_OP_SHL, dst);
 868         else {
 869             m_formatter.oneByteOp64(OP_GROUP2_EvIb, GROUP2_OP_SHL, dst);
 870             m_formatter.immediate8(imm);
 871         }
 872     }
 873 #endif // CPU(X86_64)
 874
 875     void imull_rr(RegisterID src, RegisterID dst)
 876     {
 877         m_formatter.twoByteOp(OP2_IMUL_GvEv, dst, src);
 878     }
 879
 880 #if CPU(X86_64)
 881     void imulq_rr(RegisterID src, RegisterID dst)
 882     {
 883         m_formatter.twoByteOp64(OP2_IMUL_GvEv, dst, src);
 884     }
 885 #endif // CPU(X86_64)
 886
 887     void imull_mr(int offset, RegisterID base, RegisterID dst)
 888     {
 889         m_formatter.twoByteOp(OP2_IMUL_GvEv, dst, base, offset);
 890     }
 891
 892     void imull_i32r(RegisterID src, int32_t value, RegisterID dst)
 893     {
 894         m_formatter.oneByteOp(OP_IMUL_GvEvIz, dst, src);
 895         m_formatter.immediate32(value);
 896     }
 897
 898     void idivl_r(RegisterID dst)
 899     {
 900         m_formatter.oneByteOp(OP_GROUP3_Ev, GROUP3_OP_IDIV, dst);
 901     }
 902
 903     // Comparisons:
 904
 905     void cmpl_rr(RegisterID src, RegisterID dst)
 906     {
 907         m_formatter.oneByteOp(OP_CMP_EvGv, src, dst);
 908     }
 909
 910     void cmpl_rm(RegisterID src, int offset, RegisterID base)
 911     {
 912         m_formatter.oneByteOp(OP_CMP_EvGv, src, base, offset);
 913     }
 914
 915     void cmpl_mr(int offset, RegisterID base, RegisterID src)
 916     {
 917         m_formatter.oneByteOp(OP_CMP_GvEv, src, base, offset);
 918     }
 919
 920     void cmpl_ir(int imm, RegisterID dst)
 921     {
 922         if (CAN_SIGN_EXTEND_8_32(imm)) {
 923             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
 924             m_formatter.immediate8(imm);
 925         } else {
 926             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
 927             m_formatter.immediate32(imm);
 928         }
 929     }
 930
 931     void cmpl_ir_force32(int imm, RegisterID dst)
 932     {
 933         m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
 934         m_formatter.immediate32(imm);
 935     }
 936
 937     void cmpl_im(int imm, int offset, RegisterID base)
 938     {
 939         if (CAN_SIGN_EXTEND_8_32(imm)) {
 940             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, offset);
 941             m_formatter.immediate8(imm);
 942         } else {
 943             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
 944             m_formatter.immediate32(imm);
 945         }
 946     }
 947
 948     void cmpb_im(int imm, int offset, RegisterID base)
 949     {
 950         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, base, offset);
 951         m_formatter.immediate8(imm);
 952     }
 953
 954     void cmpb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
 955     {
 956         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, base, index, scale, offset);
 957         m_formatter.immediate8(imm);
 958     }
 959
 960 #if CPU(X86)
 961     void cmpb_im(int imm, const void* addr)
 962     {
 963         m_formatter.oneByteOp(OP_GROUP1_EbIb, GROUP1_OP_CMP, addr);
 964         m_formatter.immediate8(imm);
 965     }
 966 #endif
 967
 968     void cmpl_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
 969     {
 970         if (CAN_SIGN_EXTEND_8_32(imm)) {
 971             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
 972             m_formatter.immediate8(imm);
 973         } else {
 974             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
 975             m_formatter.immediate32(imm);
 976         }
 977     }
 978
 979     void cmpl_im_force32(int imm, int offset, RegisterID base)
 980     {
 981         m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
 982         m_formatter.immediate32(imm);
 983     }
 984
 985 #if CPU(X86_64)
 986     void cmpq_rr(RegisterID src, RegisterID dst)
 987     {
 988         m_formatter.oneByteOp64(OP_CMP_EvGv, src, dst);
 989     }
 990
 991     void cmpq_rm(RegisterID src, int offset, RegisterID base)
 992     {
 993         m_formatter.oneByteOp64(OP_CMP_EvGv, src, base, offset);
 994     }
 995
 996     void cmpq_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
 997     {
 998         m_formatter.oneByteOp64(OP_CMP_EvGv, src, base, index, scale, offset);
 999     }
1000
1001     void cmpq_mr(int offset, RegisterID base, RegisterID src)
1002     {
1003         m_formatter.oneByteOp64(OP_CMP_GvEv, src, base, offset);
1004     }
1005
1006     void cmpq_ir(int imm, RegisterID dst)
1007     {
1008         if (CAN_SIGN_EXTEND_8_32(imm)) {
1009             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
1010             m_formatter.immediate8(imm);
1011         } else {
1012             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1013             m_formatter.immediate32(imm);
1014         }
1015     }
1016
1017     void cmpq_im(int imm, int offset, RegisterID base)
1018     {
1019         if (CAN_SIGN_EXTEND_8_32(imm)) {
1020             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, offset);
1021             m_formatter.immediate8(imm);
1022         } else {
1023             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, offset);
1024             m_formatter.immediate32(imm);
1025         }
1026     }
1027
1028     void cmpq_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1029     {
1030         if (CAN_SIGN_EXTEND_8_32(imm)) {
1031             m_formatter.oneByteOp64(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
1032             m_formatter.immediate8(imm);
1033         } else {
1034             m_formatter.oneByteOp64(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
1035             m_formatter.immediate32(imm);
1036         }
1037     }
1038 #else
1039     void cmpl_rm(RegisterID reg, const void* addr)
1040     {
1041         m_formatter.oneByteOp(OP_CMP_EvGv, reg, addr);
1042     }
1043
1044     void cmpl_im(int imm, const void* addr)
1045     {
1046         if (CAN_SIGN_EXTEND_8_32(imm)) {
1047             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, addr);
1048             m_formatter.immediate8(imm);
1049         } else {
1050             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, addr);
1051             m_formatter.immediate32(imm);
1052         }
1053     }
1054 #endif
1055
1056     void cmpw_ir(int imm, RegisterID dst)
1057     {
1058         if (CAN_SIGN_EXTEND_8_32(imm)) {
1059             m_formatter.prefix(PRE_OPERAND_SIZE);
1060             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, dst);
1061             m_formatter.immediate8(imm);
1062         } else {
1063             m_formatter.prefix(PRE_OPERAND_SIZE);
1064             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, dst);
1065             m_formatter.immediate16(imm);
1066         }
1067     }
1068
1069     void cmpw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1070     {
1071         m_formatter.prefix(PRE_OPERAND_SIZE);
1072         m_formatter.oneByteOp(OP_CMP_EvGv, src, base, index, scale, offset);
1073     }
1074
1075     void cmpw_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1076     {
1077         if (CAN_SIGN_EXTEND_8_32(imm)) {
1078             m_formatter.prefix(PRE_OPERAND_SIZE);
1079             m_formatter.oneByteOp(OP_GROUP1_EvIb, GROUP1_OP_CMP, base, index, scale, offset);
1080             m_formatter.immediate8(imm);
1081         } else {
1082             m_formatter.prefix(PRE_OPERAND_SIZE);
1083             m_formatter.oneByteOp(OP_GROUP1_EvIz, GROUP1_OP_CMP, base, index, scale, offset);
1084             m_formatter.immediate16(imm);
1085         }
1086     }
1087
1088     void testl_rr(RegisterID src, RegisterID dst)
1089     {
1090         m_formatter.oneByteOp(OP_TEST_EvGv, src, dst);
1091     }
1092
1093     void testl_i32r(int imm, RegisterID dst)
1094     {
1095         m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, dst);
1096         m_formatter.immediate32(imm);
1097     }
1098
1099     void testl_i32m(int imm, int offset, RegisterID base)
1100     {
1101         m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, offset);
1102         m_formatter.immediate32(imm);
1103     }
1104
1105     void testb_rr(RegisterID src, RegisterID dst)
1106     {
1107         m_formatter.oneByteOp8(OP_TEST_EbGb, src, dst);
1108     }
1109
1110     void testb_im(int imm, int offset, RegisterID base)
1111     {
1112         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, base, offset);
1113         m_formatter.immediate8(imm);
1114     }
1115
1116     void testb_im(int imm, int offset, RegisterID base, RegisterID index, int scale)
1117     {
1118         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, base, index, scale, offset);
1119         m_formatter.immediate8(imm);
1120     }
1121
1122 #if CPU(X86)
1123     void testb_im(int imm, const void* addr)
1124     {
1125         m_formatter.oneByteOp(OP_GROUP3_EbIb, GROUP3_OP_TEST, addr);
1126         m_formatter.immediate8(imm);
1127     }
1128 #endif
1129
1130     void testl_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1131     {
1132         m_formatter.oneByteOp(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, index, scale, offset);
1133         m_formatter.immediate32(imm);
1134     }
1135
1136 #if CPU(X86_64)
1137     void testq_rr(RegisterID src, RegisterID dst)
1138     {
1139         m_formatter.oneByteOp64(OP_TEST_EvGv, src, dst);
1140     }
1141
1142     void testq_rm(RegisterID src, int offset, RegisterID base)
1143     {
1144         m_formatter.oneByteOp64(OP_TEST_EvGv, src, base, offset);
1145     }
1146
1147     void testq_i32r(int imm, RegisterID dst)
1148     {
1149         m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, dst);
1150         m_formatter.immediate32(imm);
1151     }
1152
1153     void testq_i32m(int imm, int offset, RegisterID base)
1154     {
1155         m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, offset);
1156         m_formatter.immediate32(imm);
1157     }
1158
1159     void testq_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1160     {
1161         m_formatter.oneByteOp64(OP_GROUP3_EvIz, GROUP3_OP_TEST, base, index, scale, offset);
1162         m_formatter.immediate32(imm);
1163     }
1164 #endif
1165
1166     void testw_rr(RegisterID src, RegisterID dst)
1167     {
1168         m_formatter.prefix(PRE_OPERAND_SIZE);
1169         m_formatter.oneByteOp(OP_TEST_EvGv, src, dst);
1170     }
1171
1172     void testb_i8r(int imm, RegisterID dst)
1173     {
1174         m_formatter.oneByteOp8(OP_GROUP3_EbIb, GROUP3_OP_TEST, dst);
1175         m_formatter.immediate8(imm);
1176     }
1177
1178     void setCC_r(Condition cond, RegisterID dst)
1179     {
1180         m_formatter.twoByteOp8(setccOpcode(cond), (GroupOpcodeID)0, dst);
1181     }
1182
1183     void sete_r(RegisterID dst)
1184     {
1185         m_formatter.twoByteOp8(setccOpcode(ConditionE), (GroupOpcodeID)0, dst);
1186     }
1187
1188     void setz_r(RegisterID dst)
1189     {
1190         sete_r(dst);
1191     }
1192
1193     void setne_r(RegisterID dst)
1194     {
1195         m_formatter.twoByteOp8(setccOpcode(ConditionNE), (GroupOpcodeID)0, dst);
1196     }
1197
1198     void setnz_r(RegisterID dst)
1199     {
1200         setne_r(dst);
1201     }
1202
1203     // Various move ops:
1204
1205     void cdq()
1206     {
1207         m_formatter.oneByteOp(OP_CDQ);
1208     }
1209
1210     void fstpl(int offset, RegisterID base)
1211     {
1212         m_formatter.oneByteOp(OP_ESCAPE_DD, ESCAPE_DD_FSTP_doubleReal, base, offset);
1213     }
1214
1215     void xchgl_rr(RegisterID src, RegisterID dst)
1216     {
1217         if (src == X86Registers::eax)
1218             m_formatter.oneByteOp(OP_XCHG_EAX, dst);
1219         else if (dst == X86Registers::eax)
1220             m_formatter.oneByteOp(OP_XCHG_EAX, src);
1221         else
1222             m_formatter.oneByteOp(OP_XCHG_EvGv, src, dst);
1223     }
1224
1225 #if CPU(X86_64)
1226     void xchgq_rr(RegisterID src, RegisterID dst)
1227     {
1228         if (src == X86Registers::eax)
1229             m_formatter.oneByteOp64(OP_XCHG_EAX, dst);
1230         else if (dst == X86Registers::eax)
1231             m_formatter.oneByteOp64(OP_XCHG_EAX, src);
1232         else
1233             m_formatter.oneByteOp64(OP_XCHG_EvGv, src, dst);
1234     }
1235 #endif
1236
1237     void movl_rr(RegisterID src, RegisterID dst)
1238     {
1239         m_formatter.oneByteOp(OP_MOV_EvGv, src, dst);
1240     }
1241
1242     void movl_rm(RegisterID src, int offset, RegisterID base)
1243     {
1244         m_formatter.oneByteOp(OP_MOV_EvGv, src, base, offset);
1245     }
1246
1247     void movl_rm_disp32(RegisterID src, int offset, RegisterID base)
1248     {
1249         m_formatter.oneByteOp_disp32(OP_MOV_EvGv, src, base, offset);
1250     }
1251
1252     void movl_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1253     {
1254         m_formatter.oneByteOp(OP_MOV_EvGv, src, base, index, scale, offset);
1255     }
1256
1257     void movl_mEAX(const void* addr)
1258     {
1259         m_formatter.oneByteOp(OP_MOV_EAXOv);
1260 #if CPU(X86_64)
1261         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1262 #else
1263         m_formatter.immediate32(reinterpret_cast<int>(addr));
1264 #endif
1265     }
1266
1267     void movl_mr(int offset, RegisterID base, RegisterID dst)
1268     {
1269         m_formatter.oneByteOp(OP_MOV_GvEv, dst, base, offset);
1270     }
1271
1272     void movl_mr_disp32(int offset, RegisterID base, RegisterID dst)
1273     {
1274         m_formatter.oneByteOp_disp32(OP_MOV_GvEv, dst, base, offset);
1275     }
1276
1277     void movl_mr_disp8(int offset, RegisterID base, RegisterID dst)
1278     {
1279         m_formatter.oneByteOp_disp8(OP_MOV_GvEv, dst, base, offset);
1280     }
1281
1282     void movl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1283     {
1284         m_formatter.oneByteOp(OP_MOV_GvEv, dst, base, index, scale, offset);
1285     }
1286
1287     void movl_i32r(int imm, RegisterID dst)
1288     {
1289         m_formatter.oneByteOp(OP_MOV_EAXIv, dst);
1290         m_formatter.immediate32(imm);
1291     }
1292
1293     void movl_i32m(int imm, int offset, RegisterID base)
1294     {
1295         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, base, offset);
1296         m_formatter.immediate32(imm);
1297     }
1298
1299     void movl_i32m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1300     {
1301         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, base, index, scale, offset);
1302         m_formatter.immediate32(imm);
1303     }
1304
1305 #if !CPU(X86_64)
1306     void movb_i8m(int imm, const void* addr)
1307     {
1308         ASSERT(-128 <= imm && imm < 128);
1309         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, addr);
1310         m_formatter.immediate8(imm);
1311     }
1312 #endif
1313
1314     void movb_i8m(int imm, int offset, RegisterID base)
1315     {
1316         ASSERT(-128 <= imm && imm < 128);
1317         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, base, offset);
1318         m_formatter.immediate8(imm);
1319     }
1320
1321     void movb_i8m(int imm, int offset, RegisterID base, RegisterID index, int scale)
1322     {
1323         ASSERT(-128 <= imm && imm < 128);
1324         m_formatter.oneByteOp(OP_GROUP11_EvIb, GROUP11_MOV, base, index, scale, offset);
1325         m_formatter.immediate8(imm);
1326     }
1327
1328 #if !CPU(X86_64)
1329     void movb_rm(RegisterID src, const void* addr)
1330     {
1331         m_formatter.oneByteOp(OP_MOV_EbGb, src, addr);
1332     }
1333 #endif
1334
1335     void movb_rm(RegisterID src, int offset, RegisterID base)
1336     {
1337         m_formatter.oneByteOp8(OP_MOV_EbGb, src, base, offset);
1338     }
1339
1340     void movb_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1341     {
1342         m_formatter.oneByteOp8(OP_MOV_EbGb, src, base, index, scale, offset);
1343     }
1344
1345     void movw_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1346     {
1347         m_formatter.prefix(PRE_OPERAND_SIZE);
1348         m_formatter.oneByteOp8(OP_MOV_EvGv, src, base, index, scale, offset);
1349     }
1350
1351     void movl_EAXm(const void* addr)
1352     {
1353         m_formatter.oneByteOp(OP_MOV_OvEAX);
1354 #if CPU(X86_64)
1355         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1356 #else
1357         m_formatter.immediate32(reinterpret_cast<int>(addr));
1358 #endif
1359     }
1360
1361 #if CPU(X86_64)
1362     void movq_rr(RegisterID src, RegisterID dst)
1363     {
1364         m_formatter.oneByteOp64(OP_MOV_EvGv, src, dst);
1365     }
1366
1367     void movq_rm(RegisterID src, int offset, RegisterID base)
1368     {
1369         m_formatter.oneByteOp64(OP_MOV_EvGv, src, base, offset);
1370     }
1371
1372     void movq_rm_disp32(RegisterID src, int offset, RegisterID base)
1373     {
1374         m_formatter.oneByteOp64_disp32(OP_MOV_EvGv, src, base, offset);
1375     }
1376
1377     void movq_rm(RegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1378     {
1379         m_formatter.oneByteOp64(OP_MOV_EvGv, src, base, index, scale, offset);
1380     }
1381
1382     void movq_mEAX(const void* addr)
1383     {
1384         m_formatter.oneByteOp64(OP_MOV_EAXOv);
1385         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1386     }
1387
1388     void movq_EAXm(const void* addr)
1389     {
1390         m_formatter.oneByteOp64(OP_MOV_OvEAX);
1391         m_formatter.immediate64(reinterpret_cast<int64_t>(addr));
1392     }
1393
1394     void movq_mr(int offset, RegisterID base, RegisterID dst)
1395     {
1396         m_formatter.oneByteOp64(OP_MOV_GvEv, dst, base, offset);
1397     }
1398
1399     void movq_mr_disp32(int offset, RegisterID base, RegisterID dst)
1400     {
1401         m_formatter.oneByteOp64_disp32(OP_MOV_GvEv, dst, base, offset);
1402     }
1403
1404     void movq_mr_disp8(int offset, RegisterID base, RegisterID dst)
1405     {
1406         m_formatter.oneByteOp64_disp8(OP_MOV_GvEv, dst, base, offset);
1407     }
1408
1409     void movq_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1410     {
1411         m_formatter.oneByteOp64(OP_MOV_GvEv, dst, base, index, scale, offset);
1412     }
1413
1414     void movq_i32m(int imm, int offset, RegisterID base)
1415     {
1416         m_formatter.oneByteOp64(OP_GROUP11_EvIz, GROUP11_MOV, base, offset);
1417         m_formatter.immediate32(imm);
1418     }
1419
1420     void movq_i64r(int64_t imm, RegisterID dst)
1421     {
1422         m_formatter.oneByteOp64(OP_MOV_EAXIv, dst);
1423         m_formatter.immediate64(imm);
1424     }
1425
1426     void movsxd_rr(RegisterID src, RegisterID dst)
1427     {
1428         m_formatter.oneByteOp64(OP_MOVSXD_GvEv, dst, src);
1429     }
1430
1431
1432 #else
1433     void movl_rm(RegisterID src, const void* addr)
1434     {
1435         if (src == X86Registers::eax)
1436             movl_EAXm(addr);
1437         else
1438             m_formatter.oneByteOp(OP_MOV_EvGv, src, addr);
1439     }
1440
1441     void movl_mr(const void* addr, RegisterID dst)
1442     {
1443         if (dst == X86Registers::eax)
1444             movl_mEAX(addr);
1445         else
1446             m_formatter.oneByteOp(OP_MOV_GvEv, dst, addr);
1447     }
1448
1449     void movl_i32m(int imm, const void* addr)
1450     {
1451         m_formatter.oneByteOp(OP_GROUP11_EvIz, GROUP11_MOV, addr);
1452         m_formatter.immediate32(imm);
1453     }
1454 #endif
1455
1456     void movzwl_mr(int offset, RegisterID base, RegisterID dst)
1457     {
1458         m_formatter.twoByteOp(OP2_MOVZX_GvEw, dst, base, offset);
1459     }
1460
1461     void movzwl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1462     {
1463         m_formatter.twoByteOp(OP2_MOVZX_GvEw, dst, base, index, scale, offset);
1464     }
1465
1466     void movswl_mr(int offset, RegisterID base, RegisterID dst)
1467     {
1468         m_formatter.twoByteOp(OP2_MOVSX_GvEw, dst, base, offset);
1469     }
1470
1471     void movswl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1472     {
1473         m_formatter.twoByteOp(OP2_MOVSX_GvEw, dst, base, index, scale, offset);
1474     }
1475
1476     void movzbl_mr(int offset, RegisterID base, RegisterID dst)
1477     {
1478         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, base, offset);
1479     }
1480
1481     void movzbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1482     {
1483         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, base, index, scale, offset);
1484     }
1485
1486 #if !CPU(X86_64)
1487     void movzbl_mr(const void* address, RegisterID dst)
1488     {
1489         m_formatter.twoByteOp(OP2_MOVZX_GvEb, dst, address);
1490     }
1491 #endif
1492
1493     void movsbl_mr(int offset, RegisterID base, RegisterID dst)
1494     {
1495         m_formatter.twoByteOp(OP2_MOVSX_GvEb, dst, base, offset);
1496     }
1497
1498     void movsbl_mr(int offset, RegisterID base, RegisterID index, int scale, RegisterID dst)
1499     {
1500         m_formatter.twoByteOp(OP2_MOVSX_GvEb, dst, base, index, scale, offset);
1501     }
1502
1503     void movzbl_rr(RegisterID src, RegisterID dst)
1504     {
1505         // In 64-bit, this may cause an unnecessary REX to be planted (if the dst register
1506         // is in the range ESP-EDI, and the src would not have required a REX).  Unneeded
1507         // REX prefixes are defined to be silently ignored by the processor.
1508         m_formatter.twoByteOp8(OP2_MOVZX_GvEb, dst, src);
1509     }
1510
1511     void leal_mr(int offset, RegisterID base, RegisterID dst)
1512     {
1513         m_formatter.oneByteOp(OP_LEA, dst, base, offset);
1514     }
1515 #if CPU(X86_64)
1516     void leaq_mr(int offset, RegisterID base, RegisterID dst)
1517     {
1518         m_formatter.oneByteOp64(OP_LEA, dst, base, offset);
1519     }
1520 #endif
1521
1522     // Flow control:
1523
1524     AssemblerLabel call()
1525     {
1526         m_formatter.oneByteOp(OP_CALL_rel32);
1527         return m_formatter.immediateRel32();
1528     }
1529
1530     AssemblerLabel call(RegisterID dst)
1531     {
1532         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_CALLN, dst);
1533         return m_formatter.label();
1534     }
1535
1536     void call_m(int offset, RegisterID base)
1537     {
1538         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_CALLN, base, offset);
1539     }
1540
1541     AssemblerLabel jmp()
1542     {
1543         m_formatter.oneByteOp(OP_JMP_rel32);
1544         return m_formatter.immediateRel32();
1545     }
1546
1547     // Return a AssemblerLabel so we have a label to the jump, so we can use this
1548     // To make a tail recursive call on x86-64.  The MacroAssembler
1549     // really shouldn't wrap this as a Jump, since it can't be linked. :-/
1550     AssemblerLabel jmp_r(RegisterID dst)
1551     {
1552         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, dst);
1553         return m_formatter.label();
1554     }
1555
1556     void jmp_m(int offset, RegisterID base)
1557     {
1558         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, base, offset);
1559     }
1560
1561 #if !CPU(X86_64)
1562     void jmp_m(const void* address)
1563     {
1564         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, address);
1565     }
1566 #endif
1567
1568     AssemblerLabel jne()
1569     {
1570         m_formatter.twoByteOp(jccRel32(ConditionNE));
1571         return m_formatter.immediateRel32();
1572     }
1573
1574     AssemblerLabel jnz()
1575     {
1576         return jne();
1577     }
1578
1579     AssemblerLabel je()
1580     {
1581         m_formatter.twoByteOp(jccRel32(ConditionE));
1582         return m_formatter.immediateRel32();
1583     }
1584
1585     AssemblerLabel jz()
1586     {
1587         return je();
1588     }
1589
1590     AssemblerLabel jl()
1591     {
1592         m_formatter.twoByteOp(jccRel32(ConditionL));
1593         return m_formatter.immediateRel32();
1594     }
1595
1596     AssemblerLabel jb()
1597     {
1598         m_formatter.twoByteOp(jccRel32(ConditionB));
1599         return m_formatter.immediateRel32();
1600     }
1601
1602     AssemblerLabel jle()
1603     {
1604         m_formatter.twoByteOp(jccRel32(ConditionLE));
1605         return m_formatter.immediateRel32();
1606     }
1607
1608     AssemblerLabel jbe()
1609     {
1610         m_formatter.twoByteOp(jccRel32(ConditionBE));
1611         return m_formatter.immediateRel32();
1612     }
1613
1614     AssemblerLabel jge()
1615     {
1616         m_formatter.twoByteOp(jccRel32(ConditionGE));
1617         return m_formatter.immediateRel32();
1618     }
1619
1620     AssemblerLabel jg()
1621     {
1622         m_formatter.twoByteOp(jccRel32(ConditionG));
1623         return m_formatter.immediateRel32();
1624     }
1625
1626     AssemblerLabel ja()
1627     {
1628         m_formatter.twoByteOp(jccRel32(ConditionA));
1629         return m_formatter.immediateRel32();
1630     }
1631
1632     AssemblerLabel jae()
1633     {
1634         m_formatter.twoByteOp(jccRel32(ConditionAE));
1635         return m_formatter.immediateRel32();
1636     }
1637
1638     AssemblerLabel jo()
1639     {
1640         m_formatter.twoByteOp(jccRel32(ConditionO));
1641         return m_formatter.immediateRel32();
1642     }
1643
1644     AssemblerLabel jnp()
1645     {
1646         m_formatter.twoByteOp(jccRel32(ConditionNP));
1647         return m_formatter.immediateRel32();
1648     }
1649
1650     AssemblerLabel jp()
1651     {
1652         m_formatter.twoByteOp(jccRel32(ConditionP));
1653         return m_formatter.immediateRel32();
1654     }
1655
1656     AssemblerLabel js()
1657     {
1658         m_formatter.twoByteOp(jccRel32(ConditionS));
1659         return m_formatter.immediateRel32();
1660     }
1661
1662     AssemblerLabel jCC(Condition cond)
1663     {
1664         m_formatter.twoByteOp(jccRel32(cond));
1665         return m_formatter.immediateRel32();
1666     }
1667
1668     // SSE operations:
1669
1670     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
1671     {
1672         m_formatter.prefix(PRE_SSE_F2);
1673         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1674     }
1675
1676     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
1677     {
1678         m_formatter.prefix(PRE_SSE_F2);
1679         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, base, offset);
1680     }
1681
1682 #if !CPU(X86_64)
1683     void addsd_mr(const void* address, XMMRegisterID dst)
1684     {
1685         m_formatter.prefix(PRE_SSE_F2);
1686         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, address);
1687     }
1688 #endif
1689
1690     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
1691     {
1692         m_formatter.prefix(PRE_SSE_F2);
1693         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
1694     }
1695
1696 #if CPU(X86_64)
1697     void cvtsi2sdq_rr(RegisterID src, XMMRegisterID dst)
1698     {
1699         m_formatter.prefix(PRE_SSE_F2);
1700         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
1701     }
1702 #endif
1703
1704     void cvtsi2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
1705     {
1706         m_formatter.prefix(PRE_SSE_F2);
1707         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
1708     }
1709
1710 #if !CPU(X86_64)
1711     void cvtsi2sd_mr(const void* address, XMMRegisterID dst)
1712     {
1713         m_formatter.prefix(PRE_SSE_F2);
1714         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, address);
1715     }
1716 #endif
1717
1718     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
1719     {
1720         m_formatter.prefix(PRE_SSE_F2);
1721         m_formatter.twoByteOp(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
1722     }
1723
1724     void cvtsd2ss_rr(XMMRegisterID src, XMMRegisterID dst)
1725     {
1726         m_formatter.prefix(PRE_SSE_F2);
1727         m_formatter.twoByteOp(OP2_CVTSD2SS_VsdWsd, dst, (RegisterID)src);
1728     }
1729
1730     void cvtss2sd_rr(XMMRegisterID src, XMMRegisterID dst)
1731     {
1732         m_formatter.prefix(PRE_SSE_F3);
1733         m_formatter.twoByteOp(OP2_CVTSS2SD_VsdWsd, dst, (RegisterID)src);
1734     }
1735
1736 #if CPU(X86_64)
1737     void cvttsd2siq_rr(XMMRegisterID src, RegisterID dst)
1738     {
1739         m_formatter.prefix(PRE_SSE_F2);
1740         m_formatter.twoByteOp64(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
1741     }
1742 #endif
1743
1744     void movd_rr(XMMRegisterID src, RegisterID dst)
1745     {
1746         m_formatter.prefix(PRE_SSE_66);
1747         m_formatter.twoByteOp(OP2_MOVD_EdVd, (RegisterID)src, dst);
1748     }
1749
1750     void movd_rr(RegisterID src, XMMRegisterID dst)
1751     {
1752         m_formatter.prefix(PRE_SSE_66);
1753         m_formatter.twoByteOp(OP2_MOVD_VdEd, (RegisterID)dst, src);
1754     }
1755
1756 #if CPU(X86_64)
1757     void movq_rr(XMMRegisterID src, RegisterID dst)
1758     {
1759         m_formatter.prefix(PRE_SSE_66);
1760         m_formatter.twoByteOp64(OP2_MOVD_EdVd, (RegisterID)src, dst);
1761     }
1762
1763     void movq_rr(RegisterID src, XMMRegisterID dst)
1764     {
1765         m_formatter.prefix(PRE_SSE_66);
1766         m_formatter.twoByteOp64(OP2_MOVD_VdEd, (RegisterID)dst, src);
1767     }
1768 #endif
1769
1770     void movsd_rr(XMMRegisterID src, XMMRegisterID dst)
1771     {
1772         m_formatter.prefix(PRE_SSE_F2);
1773         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1774     }
1775
1776     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
1777     {
1778         m_formatter.prefix(PRE_SSE_F2);
1779         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, offset);
1780     }
1781
1782     void movsd_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1783     {
1784         m_formatter.prefix(PRE_SSE_F2);
1785         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
1786     }
1787
1788     void movss_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
1789     {
1790         m_formatter.prefix(PRE_SSE_F3);
1791         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
1792     }
1793
1794     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
1795     {
1796         m_formatter.prefix(PRE_SSE_F2);
1797         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, base, offset);
1798     }
1799
1800     void movsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
1801     {
1802         m_formatter.prefix(PRE_SSE_F2);
1803         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
1804     }
1805
1806     void movss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
1807     {
1808         m_formatter.prefix(PRE_SSE_F3);
1809         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
1810     }
1811
1812 #if !CPU(X86_64)
1813     void movsd_mr(const void* address, XMMRegisterID dst)
1814     {
1815         m_formatter.prefix(PRE_SSE_F2);
1816         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, address);
1817     }
1818     void movsd_rm(XMMRegisterID src, const void* address)
1819     {
1820         m_formatter.prefix(PRE_SSE_F2);
1821         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, address);
1822     }
1823 #endif
1824
1825     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
1826     {
1827         m_formatter.prefix(PRE_SSE_F2);
1828         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1829     }
1830
1831     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
1832     {
1833         m_formatter.prefix(PRE_SSE_F2);
1834         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, base, offset);
1835     }
1836
1837     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
1838     {
1839         m_formatter.prefix(PRE_SSE_66);
1840         m_formatter.twoByteOp(OP2_PEXTRW_GdUdIb, (RegisterID)dst, (RegisterID)src);
1841         m_formatter.immediate8(whichWord);
1842     }
1843
1844     void psllq_i8r(int imm, XMMRegisterID dst)
1845     {
1846         m_formatter.prefix(PRE_SSE_66);
1847         m_formatter.twoByteOp8(OP2_PSLLQ_UdqIb, GROUP14_OP_PSLLQ, (RegisterID)dst);
1848         m_formatter.immediate8(imm);
1849     }
1850
1851     void psrlq_i8r(int imm, XMMRegisterID dst)
1852     {
1853         m_formatter.prefix(PRE_SSE_66);
1854         m_formatter.twoByteOp8(OP2_PSRLQ_UdqIb, GROUP14_OP_PSRLQ, (RegisterID)dst);
1855         m_formatter.immediate8(imm);
1856     }
1857
1858     void por_rr(XMMRegisterID src, XMMRegisterID dst)
1859     {
1860         m_formatter.prefix(PRE_SSE_66);
1861         m_formatter.twoByteOp(OP2_POR_VdqWdq, (RegisterID)dst, (RegisterID)src);
1862     }
1863
1864     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
1865     {
1866         m_formatter.prefix(PRE_SSE_F2);
1867         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1868     }
1869
1870     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
1871     {
1872         m_formatter.prefix(PRE_SSE_F2);
1873         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, base, offset);
1874     }
1875
1876     void ucomisd_rr(XMMRegisterID src, XMMRegisterID dst)
1877     {
1878         m_formatter.prefix(PRE_SSE_66);
1879         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1880     }
1881
1882     void ucomisd_mr(int offset, RegisterID base, XMMRegisterID dst)
1883     {
1884         m_formatter.prefix(PRE_SSE_66);
1885         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, base, offset);
1886     }
1887
1888     void divsd_rr(XMMRegisterID src, XMMRegisterID dst)
1889     {
1890         m_formatter.prefix(PRE_SSE_F2);
1891         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1892     }
1893
1894     void divsd_mr(int offset, RegisterID base, XMMRegisterID dst)
1895     {
1896         m_formatter.prefix(PRE_SSE_F2);
1897         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, base, offset);
1898     }
1899
1900     void xorpd_rr(XMMRegisterID src, XMMRegisterID dst)
1901     {
1902         m_formatter.prefix(PRE_SSE_66);
1903         m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
1904     }
1905
1906     void andnpd_rr(XMMRegisterID src, XMMRegisterID dst)
1907     {
1908         m_formatter.prefix(PRE_SSE_66);
1909         m_formatter.twoByteOp(OP2_ANDNPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
1910     }
1911
1912     void sqrtsd_rr(XMMRegisterID src, XMMRegisterID dst)
1913     {
1914         m_formatter.prefix(PRE_SSE_F2);
1915         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
1916     }
1917
1918     // Misc instructions:
1919
1920     void int3()
1921     {
1922         m_formatter.oneByteOp(OP_INT3);
1923     }
1924
1925     void ret()
1926     {
1927         m_formatter.oneByteOp(OP_RET);
1928     }
1929
1930     void predictNotTaken()
1931     {
1932         m_formatter.prefix(PRE_PREDICT_BRANCH_NOT_TAKEN);
1933     }
1934
1935     void mfence()
1936     {
1937         m_formatter.threeByteOp(OP3_MFENCE);
1938     }
1939
1940     // Assembler admin methods:
1941
1942     size_t codeSize() const
1943     {
1944         return m_formatter.codeSize();
1945     }
1946
1947     AssemblerLabel labelForWatchpoint()
1948     {
1949         AssemblerLabel result = m_formatter.label();
1950         if (static_cast<int>(result.m_offset) != m_indexOfLastWatchpoint)
1951             result = label();
1952         m_indexOfLastWatchpoint = result.m_offset;
1953         m_indexOfTailOfLastWatchpoint = result.m_offset + maxJumpReplacementSize();
1954         return result;
1955     }
1956
1957     AssemblerLabel labelIgnoringWatchpoints()
1958     {
1959         return m_formatter.label();
1960     }
1961
1962     AssemblerLabel label()
1963     {
1964         AssemblerLabel result = m_formatter.label();
1965         while (UNLIKELY(static_cast<int>(result.m_offset) < m_indexOfTailOfLastWatchpoint)) {
1966             nop();
1967             result = m_formatter.label();
1968         }
1969         return result;
1970     }
1971
1972     AssemblerLabel align(int alignment)
1973     {
1974         while (!m_formatter.isAligned(alignment))
1975             m_formatter.oneByteOp(OP_HLT);
1976
1977         return label();
1978     }
1979
1980     // Linking & patching:
1981     //
1982     // 'link' and 'patch' methods are for use on unprotected code - such as the code
1983     // within the AssemblerBuffer, and code being patched by the patch buffer.  Once
1984     // code has been finalized it is (platform support permitting) within a non-
1985     // writable region of memory; to modify the code in an execute-only execuable
1986     // pool the 'repatch' and 'relink' methods should be used.
1987
1988     void linkJump(AssemblerLabel from, AssemblerLabel to)
1989     {
1990         ASSERT(from.isSet());
1991         ASSERT(to.isSet());
1992
1993         char* code = reinterpret_cast<char*>(m_formatter.data());
1994         ASSERT(!reinterpret_cast<int32_t*>(code + from.m_offset)[-1]);
1995         setRel32(code + from.m_offset, code + to.m_offset);
1996     }
1997
1998     static void linkJump(void* code, AssemblerLabel from, void* to)
1999     {
2000         ASSERT(from.isSet());
2001
2002         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2003     }
2004
2005     static void linkCall(void* code, AssemblerLabel from, void* to)
2006     {
2007         ASSERT(from.isSet());
2008
2009         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2010     }
2011
2012     static void linkPointer(void* code, AssemblerLabel where, void* value)
2013     {
2014         ASSERT(where.isSet());
2015
2016         setPointer(reinterpret_cast<char*>(code) + where.m_offset, value);
2017     }
2018
2019     static void relinkJump(void* from, void* to)
2020     {
2021         setRel32(from, to);
2022     }
2023
2024     static void relinkCall(void* from, void* to)
2025     {
2026         setRel32(from, to);
2027     }
2028
2029     static void repatchCompact(void* where, int32_t value)
2030     {
2031         ASSERT(value >= std::numeric_limits<int8_t>::min());
2032         ASSERT(value <= std::numeric_limits<int8_t>::max());
2033         setInt8(where, value);
2034     }
2035
2036     static void repatchInt32(void* where, int32_t value)
2037     {
2038         setInt32(where, value);
2039     }
2040
2041     static void repatchPointer(void* where, void* value)
2042     {
2043         setPointer(where, value);
2044     }
2045
2046     static void* readPointer(void* where)
2047     {
2048         return reinterpret_cast<void**>(where)[-1];
2049     }
2050
2051     static void replaceWithJump(void* instructionStart, void* to)
2052     {
2053         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2054         uint8_t* dstPtr = reinterpret_cast<uint8_t*>(to);
2055         intptr_t distance = (intptr_t)(dstPtr - (ptr + 5));
2056         ptr[0] = static_cast<uint8_t>(OP_JMP_rel32);
2057         *reinterpret_cast<int32_t*>(ptr + 1) = static_cast<int32_t>(distance);
2058     }
2059
2060     static ptrdiff_t maxJumpReplacementSize()
2061     {
2062         return 5;
2063     }
2064
2065 #if CPU(X86_64)
2066     static void revertJumpTo_movq_i64r(void* instructionStart, int64_t imm, RegisterID dst)
2067     {
2068         const unsigned instructionSize = 10; // REX.W MOV IMM64
2069         const int rexBytes = 1;
2070         const int opcodeBytes = 1;
2071         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2072         ptr[0] = PRE_REX | (1 << 3) | (dst >> 3);
2073         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2074
2075         union {
2076             uint64_t asWord;
2077             uint8_t asBytes[8];
2078         } u;
2079         u.asWord = imm;
2080         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2081             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2082     }
2083
2084     static void revertJumpTo_movl_i32r(void* instructionStart, int32_t imm, RegisterID dst)
2085     {
2086         // We only revert jumps on inline caches, and inline caches always use the scratch register (r11).
2087         // FIXME: If the above is ever false then we need to make this smarter with respect to emitting
2088         // the REX byte.
2089         ASSERT(dst == X86Registers::r11);
2090         const unsigned instructionSize = 6; // REX MOV IMM32
2091         const int rexBytes = 1;
2092         const int opcodeBytes = 1;
2093         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2094         ptr[0] = PRE_REX | (dst >> 3);
2095         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2096
2097         union {
2098             uint32_t asWord;
2099             uint8_t asBytes[4];
2100         } u;
2101         u.asWord = imm;
2102         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2103             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2104     }
2105 #endif
2106
2107     static void revertJumpTo_cmpl_ir_force32(void* instructionStart, int32_t imm, RegisterID dst)
2108     {
2109         const int opcodeBytes = 1;
2110         const int modRMBytes = 1;
2111         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2112         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2113         ptr[0] = OP_GROUP1_EvIz;
2114         ptr[1] = (X86InstructionFormatter::ModRmRegister << 6) | (GROUP1_OP_CMP << 3) | dst;
2115         union {
2116             uint32_t asWord;
2117             uint8_t asBytes[4];
2118         } u;
2119         u.asWord = imm;
2120         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2121             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2122     }
2123
2124     static void revertJumpTo_cmpl_im_force32(void* instructionStart, int32_t imm, int offset, RegisterID dst)
2125     {
2126         ASSERT_UNUSED(offset, !offset);
2127         const int opcodeBytes = 1;
2128         const int modRMBytes = 1;
2129         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2130         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2131         ptr[0] = OP_GROUP1_EvIz;
2132         ptr[1] = (X86InstructionFormatter::ModRmMemoryNoDisp << 6) | (GROUP1_OP_CMP << 3) | dst;
2133         union {
2134             uint32_t asWord;
2135             uint8_t asBytes[4];
2136         } u;
2137         u.asWord = imm;
2138         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2139             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2140     }
2141
2142     static void replaceWithLoad(void* instructionStart)
2143     {
2144         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2145 #if CPU(X86_64)
2146         if ((*ptr & ~15) == PRE_REX)
2147             ptr++;
2148 #endif
2149         switch (*ptr) {
2150         case OP_MOV_GvEv:
2151             break;
2152         case OP_LEA:
2153             *ptr = OP_MOV_GvEv;
2154             break;
2155         default:
2156             RELEASE_ASSERT_NOT_REACHED();
2157         }
2158     }
2159
2160     static void replaceWithAddressComputation(void* instructionStart)
2161     {
2162         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2163 #if CPU(X86_64)
2164         if ((*ptr & ~15) == PRE_REX)
2165             ptr++;
2166 #endif
2167         switch (*ptr) {
2168         case OP_MOV_GvEv:
2169             *ptr = OP_LEA;
2170             break;
2171         case OP_LEA:
2172             break;
2173         default:
2174             RELEASE_ASSERT_NOT_REACHED();
2175         }
2176     }
2177
2178     static unsigned getCallReturnOffset(AssemblerLabel call)
2179     {
2180         ASSERT(call.isSet());
2181         return call.m_offset;
2182     }
2183
2184     static void* getRelocatedAddress(void* code, AssemblerLabel label)
2185     {
2186         ASSERT(label.isSet());
2187         return reinterpret_cast<void*>(reinterpret_cast<ptrdiff_t>(code) + label.m_offset);
2188     }
2189
2190     static int getDifferenceBetweenLabels(AssemblerLabel a, AssemblerLabel b)
2191     {
2192         return b.m_offset - a.m_offset;
2193     }
2194
2195     unsigned debugOffset() { return m_formatter.debugOffset(); }
2196
2197     void nop()
2198     {
2199         m_formatter.oneByteOp(OP_NOP);
2200     }
2201
2202     static void fillNops(void* base, size_t size)
2203     {
2204         memset(base, OP_NOP, size);
2205     }
2206
2207     // This is a no-op on x86
2208     ALWAYS_INLINE static void cacheFlush(void*, size_t) { }
2209
2210 private:
2211
2212     static void setPointer(void* where, void* value)
2213     {
2214         reinterpret_cast<void**>(where)[-1] = value;
2215     }
2216
2217     static void setInt32(void* where, int32_t value)
2218     {
2219         reinterpret_cast<int32_t*>(where)[-1] = value;
2220     }
2221
2222     static void setInt8(void* where, int8_t value)
2223     {
2224         reinterpret_cast<int8_t*>(where)[-1] = value;
2225     }
2226
2227     static void setRel32(void* from, void* to)
2228     {
2229         intptr_t offset = reinterpret_cast<intptr_t>(to) - reinterpret_cast<intptr_t>(from);
2230         ASSERT(offset == static_cast<int32_t>(offset));
2231
2232         setInt32(from, offset);
2233     }
2234
2235     class X86InstructionFormatter {
2236
2237         static const int maxInstructionSize = 16;
2238
2239     public:
2240
2241         enum ModRmMode {
2242             ModRmMemoryNoDisp,
2243             ModRmMemoryDisp8,
2244             ModRmMemoryDisp32,
2245             ModRmRegister,
2246         };
2247
2248         // Legacy prefix bytes:
2249         //
2250         // These are emmitted prior to the instruction.
2251
2252         void prefix(OneByteOpcodeID pre)
2253         {
2254             m_buffer.putByte(pre);
2255         }
2256
2257         // Word-sized operands / no operand instruction formatters.
2258         //
2259         // In addition to the opcode, the following operand permutations are supported:
2260         //   * None - instruction takes no operands.
2261         //   * One register - the low three bits of the RegisterID are added into the opcode.
2262         //   * 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).
2263         //   * Three argument ModRM - a register, and a register and an offset describing a memory operand.
2264         //   * Five argument ModRM - a register, and a base register, an index, scale, and offset describing a memory operand.
2265         //
2266         // For 32-bit x86 targets, the address operand may also be provided as a void*.
2267         // On 64-bit targets REX prefixes will be planted as necessary, where high numbered registers are used.
2268         //
2269         // The twoByteOp methods plant two-byte Intel instructions sequences (first opcode byte 0x0F).
2270
2271         void oneByteOp(OneByteOpcodeID opcode)
2272         {
2273             m_buffer.ensureSpace(maxInstructionSize);
2274             m_buffer.putByteUnchecked(opcode);
2275         }
2276
2277         void oneByteOp(OneByteOpcodeID opcode, RegisterID reg)
2278         {
2279             m_buffer.ensureSpace(maxInstructionSize);
2280             emitRexIfNeeded(0, 0, reg);
2281             m_buffer.putByteUnchecked(opcode + (reg & 7));
2282         }
2283
2284         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID rm)
2285         {
2286             m_buffer.ensureSpace(maxInstructionSize);
2287             emitRexIfNeeded(reg, 0, rm);
2288             m_buffer.putByteUnchecked(opcode);
2289             registerModRM(reg, rm);
2290         }
2291
2292         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2293         {
2294             m_buffer.ensureSpace(maxInstructionSize);
2295             emitRexIfNeeded(reg, 0, base);
2296             m_buffer.putByteUnchecked(opcode);
2297             memoryModRM(reg, base, offset);
2298         }
2299
2300         void oneByteOp_disp32(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2301         {
2302             m_buffer.ensureSpace(maxInstructionSize);
2303             emitRexIfNeeded(reg, 0, base);
2304             m_buffer.putByteUnchecked(opcode);
2305             memoryModRM_disp32(reg, base, offset);
2306         }
2307
2308         void oneByteOp_disp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2309         {
2310             m_buffer.ensureSpace(maxInstructionSize);
2311             emitRexIfNeeded(reg, 0, base);
2312             m_buffer.putByteUnchecked(opcode);
2313             memoryModRM_disp8(reg, base, offset);
2314         }
2315
2316         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
2317         {
2318             m_buffer.ensureSpace(maxInstructionSize);
2319             emitRexIfNeeded(reg, index, base);
2320             m_buffer.putByteUnchecked(opcode);
2321             memoryModRM(reg, base, index, scale, offset);
2322         }
2323
2324 #if !CPU(X86_64)
2325         void oneByteOp(OneByteOpcodeID opcode, int reg, const void* address)
2326         {
2327             m_buffer.ensureSpace(maxInstructionSize);
2328             m_buffer.putByteUnchecked(opcode);
2329             memoryModRM(reg, address);
2330         }
2331 #endif
2332
2333         void twoByteOp(TwoByteOpcodeID opcode)
2334         {
2335             m_buffer.ensureSpace(maxInstructionSize);
2336             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2337             m_buffer.putByteUnchecked(opcode);
2338         }
2339
2340         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID rm)
2341         {
2342             m_buffer.ensureSpace(maxInstructionSize);
2343             emitRexIfNeeded(reg, 0, rm);
2344             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2345             m_buffer.putByteUnchecked(opcode);
2346             registerModRM(reg, rm);
2347         }
2348
2349         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID base, int offset)
2350         {
2351             m_buffer.ensureSpace(maxInstructionSize);
2352             emitRexIfNeeded(reg, 0, base);
2353             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2354             m_buffer.putByteUnchecked(opcode);
2355             memoryModRM(reg, base, offset);
2356         }
2357
2358         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
2359         {
2360             m_buffer.ensureSpace(maxInstructionSize);
2361             emitRexIfNeeded(reg, index, base);
2362             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2363             m_buffer.putByteUnchecked(opcode);
2364             memoryModRM(reg, base, index, scale, offset);
2365         }
2366
2367 #if !CPU(X86_64)
2368         void twoByteOp(TwoByteOpcodeID opcode, int reg, const void* address)
2369         {
2370             m_buffer.ensureSpace(maxInstructionSize);
2371             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2372             m_buffer.putByteUnchecked(opcode);
2373             memoryModRM(reg, address);
2374         }
2375 #endif
2376
2377         void threeByteOp(ThreeByteOpcodeID opcode)
2378         {
2379             m_buffer.ensureSpace(maxInstructionSize);
2380             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2381             m_buffer.putByteUnchecked(OP2_3BYTE_ESCAPE);
2382             m_buffer.putByteUnchecked(opcode);
2383         }
2384
2385 #if CPU(X86_64)
2386         // Quad-word-sized operands:
2387         //
2388         // Used to format 64-bit operantions, planting a REX.w prefix.
2389         // When planting d64 or f64 instructions, not requiring a REX.w prefix,
2390         // the normal (non-'64'-postfixed) formatters should be used.
2391
2392         void oneByteOp64(OneByteOpcodeID opcode)
2393         {
2394             m_buffer.ensureSpace(maxInstructionSize);
2395             emitRexW(0, 0, 0);
2396             m_buffer.putByteUnchecked(opcode);
2397         }
2398
2399         void oneByteOp64(OneByteOpcodeID opcode, RegisterID reg)
2400         {
2401             m_buffer.ensureSpace(maxInstructionSize);
2402             emitRexW(0, 0, reg);
2403             m_buffer.putByteUnchecked(opcode + (reg & 7));
2404         }
2405
2406         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID rm)
2407         {
2408             m_buffer.ensureSpace(maxInstructionSize);
2409             emitRexW(reg, 0, rm);
2410             m_buffer.putByteUnchecked(opcode);
2411             registerModRM(reg, rm);
2412         }
2413
2414         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2415         {
2416             m_buffer.ensureSpace(maxInstructionSize);
2417             emitRexW(reg, 0, base);
2418             m_buffer.putByteUnchecked(opcode);
2419             memoryModRM(reg, base, offset);
2420         }
2421
2422         void oneByteOp64_disp32(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2423         {
2424             m_buffer.ensureSpace(maxInstructionSize);
2425             emitRexW(reg, 0, base);
2426             m_buffer.putByteUnchecked(opcode);
2427             memoryModRM_disp32(reg, base, offset);
2428         }
2429
2430         void oneByteOp64_disp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2431         {
2432             m_buffer.ensureSpace(maxInstructionSize);
2433             emitRexW(reg, 0, base);
2434             m_buffer.putByteUnchecked(opcode);
2435             memoryModRM_disp8(reg, base, offset);
2436         }
2437
2438         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
2439         {
2440             m_buffer.ensureSpace(maxInstructionSize);
2441             emitRexW(reg, index, base);
2442             m_buffer.putByteUnchecked(opcode);
2443             memoryModRM(reg, base, index, scale, offset);
2444         }
2445
2446         void twoByteOp64(TwoByteOpcodeID opcode, int reg, RegisterID rm)
2447         {
2448             m_buffer.ensureSpace(maxInstructionSize);
2449             emitRexW(reg, 0, rm);
2450             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2451             m_buffer.putByteUnchecked(opcode);
2452             registerModRM(reg, rm);
2453         }
2454 #endif
2455
2456         // Byte-operands:
2457         //
2458         // These methods format byte operations.  Byte operations differ from the normal
2459         // formatters in the circumstances under which they will decide to emit REX prefixes.
2460         // These should be used where any register operand signifies a byte register.
2461         //
2462         // The disctinction is due to the handling of register numbers in the range 4..7 on
2463         // x86-64.  These register numbers may either represent the second byte of the first
2464         // four registers (ah..bh) or the first byte of the second four registers (spl..dil).
2465         //
2466         // Since ah..bh cannot be used in all permutations of operands (specifically cannot
2467         // be accessed where a REX prefix is present), these are likely best treated as
2468         // deprecated.  In order to ensure the correct registers spl..dil are selected a
2469         // REX prefix will be emitted for any byte register operand in the range 4..15.
2470         //
2471         // These formatters may be used in instructions where a mix of operand sizes, in which
2472         // case an unnecessary REX will be emitted, for example:
2473         //     movzbl %al, %edi
2474         // In this case a REX will be planted since edi is 7 (and were this a byte operand
2475         // a REX would be required to specify dil instead of bh).  Unneeded REX prefixes will
2476         // be silently ignored by the processor.
2477         //
2478         // Address operands should still be checked using regRequiresRex(), while byteRegRequiresRex()
2479         // is provided to check byte register operands.
2480
2481         void oneByteOp8(OneByteOpcodeID opcode, GroupOpcodeID groupOp, RegisterID rm)
2482         {
2483             m_buffer.ensureSpace(maxInstructionSize);
2484             emitRexIf(byteRegRequiresRex(rm), 0, 0, rm);
2485             m_buffer.putByteUnchecked(opcode);
2486             registerModRM(groupOp, rm);
2487         }
2488
2489         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID rm)
2490         {
2491             m_buffer.ensureSpace(maxInstructionSize);
2492             emitRexIf(byteRegRequiresRex(reg) || byteRegRequiresRex(rm), reg, 0, rm);
2493             m_buffer.putByteUnchecked(opcode);
2494             registerModRM(reg, rm);
2495         }
2496
2497         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
2498         {
2499             m_buffer.ensureSpace(maxInstructionSize);
2500             emitRexIf(byteRegRequiresRex(reg) || byteRegRequiresRex(base), reg, 0, base);
2501             m_buffer.putByteUnchecked(opcode);
2502             memoryModRM(reg, base, offset);
2503         }
2504
2505         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
2506         {
2507             m_buffer.ensureSpace(maxInstructionSize);
2508             emitRexIf(byteRegRequiresRex(reg) || regRequiresRex(index) || regRequiresRex(base), reg, index, base);
2509             m_buffer.putByteUnchecked(opcode);
2510             memoryModRM(reg, base, index, scale, offset);
2511         }
2512
2513         void twoByteOp8(TwoByteOpcodeID opcode, RegisterID reg, RegisterID rm)
2514         {
2515             m_buffer.ensureSpace(maxInstructionSize);
2516             emitRexIf(byteRegRequiresRex(reg)|byteRegRequiresRex(rm), reg, 0, rm);
2517             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2518             m_buffer.putByteUnchecked(opcode);
2519             registerModRM(reg, rm);
2520         }
2521
2522         void twoByteOp8(TwoByteOpcodeID opcode, GroupOpcodeID groupOp, RegisterID rm)
2523         {
2524             m_buffer.ensureSpace(maxInstructionSize);
2525             emitRexIf(byteRegRequiresRex(rm), 0, 0, rm);
2526             m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
2527             m_buffer.putByteUnchecked(opcode);
2528             registerModRM(groupOp, rm);
2529         }
2530
2531         // Immediates:
2532         //
2533         // An immedaite should be appended where appropriate after an op has been emitted.
2534         // The writes are unchecked since the opcode formatters above will have ensured space.
2535
2536         void immediate8(int imm)
2537         {
2538             m_buffer.putByteUnchecked(imm);
2539         }
2540
2541         void immediate16(int imm)
2542         {
2543             m_buffer.putShortUnchecked(imm);
2544         }
2545
2546         void immediate32(int imm)
2547         {
2548             m_buffer.putIntUnchecked(imm);
2549         }
2550
2551         void immediate64(int64_t imm)
2552         {
2553             m_buffer.putInt64Unchecked(imm);
2554         }
2555
2556         AssemblerLabel immediateRel32()
2557         {
2558             m_buffer.putIntUnchecked(0);
2559             return label();
2560         }
2561
2562         // Administrative methods:
2563
2564         size_t codeSize() const { return m_buffer.codeSize(); }
2565         AssemblerLabel label() const { return m_buffer.label(); }
2566         bool isAligned(int alignment) const { return m_buffer.isAligned(alignment); }
2567         void* data() const { return m_buffer.data(); }
2568
2569         unsigned debugOffset() { return m_buffer.debugOffset(); }
2570
2571     private:
2572
2573         // Internals; ModRm and REX formatters.
2574
2575         static const RegisterID noBase = X86Registers::ebp;
2576         static const RegisterID hasSib = X86Registers::esp;
2577         static const RegisterID noIndex = X86Registers::esp;
2578 #if CPU(X86_64)
2579         static const RegisterID noBase2 = X86Registers::r13;
2580         static const RegisterID hasSib2 = X86Registers::r12;
2581
2582         // Registers r8 & above require a REX prefixe.
2583         inline bool regRequiresRex(int reg)
2584         {
2585             return (reg >= X86Registers::r8);
2586         }
2587
2588         // Byte operand register spl & above require a REX prefix (to prevent the 'H' registers be accessed).
2589         inline bool byteRegRequiresRex(int reg)
2590         {
2591             return (reg >= X86Registers::esp);
2592         }
2593
2594         // Format a REX prefix byte.
2595         inline void emitRex(bool w, int r, int x, int b)
2596         {
2597             ASSERT(r >= 0);
2598             ASSERT(x >= 0);
2599             ASSERT(b >= 0);
2600             m_buffer.putByteUnchecked(PRE_REX | ((int)w << 3) | ((r>>3)<<2) | ((x>>3)<<1) | (b>>3));
2601         }
2602
2603         // Used to plant a REX byte with REX.w set (for 64-bit operations).
2604         inline void emitRexW(int r, int x, int b)
2605         {
2606             emitRex(true, r, x, b);
2607         }
2608
2609         // Used for operations with byte operands - use byteRegRequiresRex() to check register operands,
2610         // regRequiresRex() to check other registers (i.e. address base & index).
2611         inline void emitRexIf(bool condition, int r, int x, int b)
2612         {
2613             if (condition) emitRex(false, r, x, b);
2614         }
2615
2616         // Used for word sized operations, will plant a REX prefix if necessary (if any register is r8 or above).
2617         inline void emitRexIfNeeded(int r, int x, int b)
2618         {
2619             emitRexIf(regRequiresRex(r) || regRequiresRex(x) || regRequiresRex(b), r, x, b);
2620         }
2621 #else
2622         // No REX prefix bytes on 32-bit x86.
2623         inline bool regRequiresRex(int) { return false; }
2624         inline bool byteRegRequiresRex(int) { return false; }
2625         inline void emitRexIf(bool, int, int, int) {}
2626         inline void emitRexIfNeeded(int, int, int) {}
2627 #endif
2628
2629         void putModRm(ModRmMode mode, int reg, RegisterID rm)
2630         {
2631             m_buffer.putByteUnchecked((mode << 6) | ((reg & 7) << 3) | (rm & 7));
2632         }
2633
2634         void putModRmSib(ModRmMode mode, int reg, RegisterID base, RegisterID index, int scale)
2635         {
2636             ASSERT(mode != ModRmRegister);
2637
2638             putModRm(mode, reg, hasSib);
2639             m_buffer.putByteUnchecked((scale << 6) | ((index & 7) << 3) | (base & 7));
2640         }
2641
2642         void registerModRM(int reg, RegisterID rm)
2643         {
2644             putModRm(ModRmRegister, reg, rm);
2645         }
2646
2647         void memoryModRM(int reg, RegisterID base, int offset)
2648         {
2649             // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
2650 #if CPU(X86_64)
2651             if ((base == hasSib) || (base == hasSib2)) {
2652 #else
2653             if (base == hasSib) {
2654 #endif
2655                 if (!offset) // No need to check if the base is noBase, since we know it is hasSib!
2656                     putModRmSib(ModRmMemoryNoDisp, reg, base, noIndex, 0);
2657                 else if (CAN_SIGN_EXTEND_8_32(offset)) {
2658                     putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
2659                     m_buffer.putByteUnchecked(offset);
2660                 } else {
2661                     putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
2662                     m_buffer.putIntUnchecked(offset);
2663                 }
2664             } else {
2665 #if CPU(X86_64)
2666                 if (!offset && (base != noBase) && (base != noBase2))
2667 #else
2668                 if (!offset && (base != noBase))
2669 #endif
2670                     putModRm(ModRmMemoryNoDisp, reg, base);
2671                 else if (CAN_SIGN_EXTEND_8_32(offset)) {
2672                     putModRm(ModRmMemoryDisp8, reg, base);
2673                     m_buffer.putByteUnchecked(offset);
2674                 } else {
2675                     putModRm(ModRmMemoryDisp32, reg, base);
2676                     m_buffer.putIntUnchecked(offset);
2677                 }
2678             }
2679         }
2680
2681         void memoryModRM_disp8(int reg, RegisterID base, int offset)
2682         {
2683             // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
2684             ASSERT(CAN_SIGN_EXTEND_8_32(offset));
2685 #if CPU(X86_64)
2686             if ((base == hasSib) || (base == hasSib2)) {
2687 #else
2688             if (base == hasSib) {
2689 #endif
2690                 putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
2691                 m_buffer.putByteUnchecked(offset);
2692             } else {
2693                 putModRm(ModRmMemoryDisp8, reg, base);
2694                 m_buffer.putByteUnchecked(offset);
2695             }
2696         }
2697
2698         void memoryModRM_disp32(int reg, RegisterID base, int offset)
2699         {
2700             // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
2701 #if CPU(X86_64)
2702             if ((base == hasSib) || (base == hasSib2)) {
2703 #else
2704             if (base == hasSib) {
2705 #endif
2706                 putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
2707                 m_buffer.putIntUnchecked(offset);
2708             } else {
2709                 putModRm(ModRmMemoryDisp32, reg, base);
2710                 m_buffer.putIntUnchecked(offset);
2711             }
2712         }
2713
2714         void memoryModRM(int reg, RegisterID base, RegisterID index, int scale, int offset)
2715         {
2716             ASSERT(index != noIndex);
2717
2718 #if CPU(X86_64)
2719             if (!offset && (base != noBase) && (base != noBase2))
2720 #else
2721             if (!offset && (base != noBase))
2722 #endif
2723                 putModRmSib(ModRmMemoryNoDisp, reg, base, index, scale);
2724             else if (CAN_SIGN_EXTEND_8_32(offset)) {
2725                 putModRmSib(ModRmMemoryDisp8, reg, base, index, scale);
2726                 m_buffer.putByteUnchecked(offset);
2727             } else {
2728                 putModRmSib(ModRmMemoryDisp32, reg, base, index, scale);
2729                 m_buffer.putIntUnchecked(offset);
2730             }
2731         }
2732
2733 #if !CPU(X86_64)
2734         void memoryModRM(int reg, const void* address)
2735         {
2736             // noBase + ModRmMemoryNoDisp means noBase + ModRmMemoryDisp32!
2737             putModRm(ModRmMemoryNoDisp, reg, noBase);
2738             m_buffer.putIntUnchecked(reinterpret_cast<int32_t>(address));
2739         }
2740 #endif
2741
2742     public:
2743         AssemblerBuffer m_buffer;
2744     } m_formatter;
2745     int m_indexOfLastWatchpoint;
2746     int m_indexOfTailOfLastWatchpoint;
2747 };
2748
2749 } // namespace JSC
2750
2751 #endif // ENABLE(ASSEMBLER) && CPU(X86)
2752
2753 #endif // X86Assembler_h