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