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