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