[JSC] Improve int->float conversion in FTL
[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 #if !CPU(X86_64)
1987     void jmp_m(const void* address)
1988     {
1989         m_formatter.oneByteOp(OP_GROUP5_Ev, GROUP5_OP_JMPN, address);
1990     }
1991 #endif
1992
1993     AssemblerLabel jne()
1994     {
1995         m_formatter.twoByteOp(jccRel32(ConditionNE));
1996         return m_formatter.immediateRel32();
1997     }
1998     
1999     AssemblerLabel jnz()
2000     {
2001         return jne();
2002     }
2003
2004     AssemblerLabel je()
2005     {
2006         m_formatter.twoByteOp(jccRel32(ConditionE));
2007         return m_formatter.immediateRel32();
2008     }
2009     
2010     AssemblerLabel jz()
2011     {
2012         return je();
2013     }
2014
2015     AssemblerLabel jl()
2016     {
2017         m_formatter.twoByteOp(jccRel32(ConditionL));
2018         return m_formatter.immediateRel32();
2019     }
2020     
2021     AssemblerLabel jb()
2022     {
2023         m_formatter.twoByteOp(jccRel32(ConditionB));
2024         return m_formatter.immediateRel32();
2025     }
2026     
2027     AssemblerLabel jle()
2028     {
2029         m_formatter.twoByteOp(jccRel32(ConditionLE));
2030         return m_formatter.immediateRel32();
2031     }
2032     
2033     AssemblerLabel jbe()
2034     {
2035         m_formatter.twoByteOp(jccRel32(ConditionBE));
2036         return m_formatter.immediateRel32();
2037     }
2038     
2039     AssemblerLabel jge()
2040     {
2041         m_formatter.twoByteOp(jccRel32(ConditionGE));
2042         return m_formatter.immediateRel32();
2043     }
2044
2045     AssemblerLabel jg()
2046     {
2047         m_formatter.twoByteOp(jccRel32(ConditionG));
2048         return m_formatter.immediateRel32();
2049     }
2050
2051     AssemblerLabel ja()
2052     {
2053         m_formatter.twoByteOp(jccRel32(ConditionA));
2054         return m_formatter.immediateRel32();
2055     }
2056     
2057     AssemblerLabel jae()
2058     {
2059         m_formatter.twoByteOp(jccRel32(ConditionAE));
2060         return m_formatter.immediateRel32();
2061     }
2062     
2063     AssemblerLabel jo()
2064     {
2065         m_formatter.twoByteOp(jccRel32(ConditionO));
2066         return m_formatter.immediateRel32();
2067     }
2068
2069     AssemblerLabel jnp()
2070     {
2071         m_formatter.twoByteOp(jccRel32(ConditionNP));
2072         return m_formatter.immediateRel32();
2073     }
2074
2075     AssemblerLabel jp()
2076     {
2077         m_formatter.twoByteOp(jccRel32(ConditionP));
2078         return m_formatter.immediateRel32();
2079     }
2080     
2081     AssemblerLabel js()
2082     {
2083         m_formatter.twoByteOp(jccRel32(ConditionS));
2084         return m_formatter.immediateRel32();
2085     }
2086
2087     AssemblerLabel jCC(Condition cond)
2088     {
2089         m_formatter.twoByteOp(jccRel32(cond));
2090         return m_formatter.immediateRel32();
2091     }
2092
2093     // SSE operations:
2094
2095     void addsd_rr(XMMRegisterID src, XMMRegisterID dst)
2096     {
2097         m_formatter.prefix(PRE_SSE_F2);
2098         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2099     }
2100
2101     void vaddsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2102     {
2103         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2104     }
2105
2106     void addsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2107     {
2108         m_formatter.prefix(PRE_SSE_F2);
2109         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, base, offset);
2110     }
2111
2112     void addsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2113     {
2114         m_formatter.prefix(PRE_SSE_F2);
2115         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, dst, base, index, scale, offset);
2116     }
2117
2118     void vaddsd_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2119     {
2120         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2121     }
2122
2123     void vaddsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2124     {
2125         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2126     }
2127
2128     void addss_rr(XMMRegisterID src, XMMRegisterID dst)
2129     {
2130         m_formatter.prefix(PRE_SSE_F3);
2131         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2132     }
2133
2134     void vaddss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2135     {
2136         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2137     }
2138
2139     void addss_mr(int offset, RegisterID base, XMMRegisterID dst)
2140     {
2141         m_formatter.prefix(PRE_SSE_F3);
2142         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, base, offset);
2143     }
2144
2145     void addss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2146     {
2147         m_formatter.prefix(PRE_SSE_F3);
2148         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, dst, base, index, scale, offset);
2149     }
2150
2151     void vaddss_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2152     {
2153         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2154     }
2155
2156     void vaddss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2157     {
2158         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_ADDSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2159     }
2160
2161 #if !CPU(X86_64)
2162     void addsd_mr(const void* address, XMMRegisterID dst)
2163     {
2164         m_formatter.prefix(PRE_SSE_F2);
2165         m_formatter.twoByteOp(OP2_ADDSD_VsdWsd, (RegisterID)dst, address);
2166     }
2167 #endif
2168
2169     void cvtsi2sd_rr(RegisterID src, XMMRegisterID dst)
2170     {
2171         m_formatter.prefix(PRE_SSE_F2);
2172         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2173     }
2174
2175     void cvtsi2ss_rr(RegisterID src, XMMRegisterID dst)
2176     {
2177         m_formatter.prefix(PRE_SSE_F3);
2178         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2179     }
2180
2181 #if CPU(X86_64)
2182     void cvtsi2sdq_rr(RegisterID src, XMMRegisterID dst)
2183     {
2184         m_formatter.prefix(PRE_SSE_F2);
2185         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2186     }
2187
2188     void cvtsi2ssq_rr(RegisterID src, XMMRegisterID dst)
2189     {
2190         m_formatter.prefix(PRE_SSE_F3);
2191         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, src);
2192     }
2193
2194     void cvtsi2sdq_mr(int offset, RegisterID base, XMMRegisterID dst)
2195     {
2196         m_formatter.prefix(PRE_SSE_F2);
2197         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2198     }
2199
2200     void cvtsi2ssq_mr(int offset, RegisterID base, XMMRegisterID dst)
2201     {
2202         m_formatter.prefix(PRE_SSE_F3);
2203         m_formatter.twoByteOp64(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2204     }
2205 #endif
2206
2207     void cvtsi2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
2208     {
2209         m_formatter.prefix(PRE_SSE_F2);
2210         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2211     }
2212
2213     void cvtsi2ss_mr(int offset, RegisterID base, XMMRegisterID dst)
2214     {
2215         m_formatter.prefix(PRE_SSE_F3);
2216         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, base, offset);
2217     }
2218
2219 #if !CPU(X86_64)
2220     void cvtsi2sd_mr(const void* address, XMMRegisterID dst)
2221     {
2222         m_formatter.prefix(PRE_SSE_F2);
2223         m_formatter.twoByteOp(OP2_CVTSI2SD_VsdEd, (RegisterID)dst, address);
2224     }
2225 #endif
2226
2227     void cvttsd2si_rr(XMMRegisterID src, RegisterID dst)
2228     {
2229         m_formatter.prefix(PRE_SSE_F2);
2230         m_formatter.twoByteOp(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
2231     }
2232
2233     void cvtsd2ss_rr(XMMRegisterID src, XMMRegisterID dst)
2234     {
2235         m_formatter.prefix(PRE_SSE_F2);
2236         m_formatter.twoByteOp(OP2_CVTSD2SS_VsdWsd, dst, (RegisterID)src);
2237     }
2238
2239     void cvtsd2ss_mr(int offset, RegisterID base, XMMRegisterID dst)
2240     {
2241         m_formatter.prefix(PRE_SSE_F2);
2242         m_formatter.twoByteOp(OP2_CVTSD2SS_VsdWsd, dst, base, offset);
2243     }
2244
2245     void cvtss2sd_rr(XMMRegisterID src, XMMRegisterID dst)
2246     {
2247         m_formatter.prefix(PRE_SSE_F3);
2248         m_formatter.twoByteOp(OP2_CVTSS2SD_VsdWsd, dst, (RegisterID)src);
2249     }
2250
2251     void cvtss2sd_mr(int offset, RegisterID base, XMMRegisterID dst)
2252     {
2253         m_formatter.prefix(PRE_SSE_F3);
2254         m_formatter.twoByteOp(OP2_CVTSS2SD_VsdWsd, dst, base, offset);
2255     }
2256
2257 #if CPU(X86_64)
2258     void cvttsd2siq_rr(XMMRegisterID src, RegisterID dst)
2259     {
2260         m_formatter.prefix(PRE_SSE_F2);
2261         m_formatter.twoByteOp64(OP2_CVTTSD2SI_GdWsd, dst, (RegisterID)src);
2262     }
2263 #endif
2264
2265     void movd_rr(XMMRegisterID src, RegisterID dst)
2266     {
2267         m_formatter.prefix(PRE_SSE_66);
2268         m_formatter.twoByteOp(OP2_MOVD_EdVd, (RegisterID)src, dst);
2269     }
2270
2271     void movd_rr(RegisterID src, XMMRegisterID dst)
2272     {
2273         m_formatter.prefix(PRE_SSE_66);
2274         m_formatter.twoByteOp(OP2_MOVD_VdEd, (RegisterID)dst, src);
2275     }
2276
2277 #if CPU(X86_64)
2278     void movmskpd_rr(XMMRegisterID src, RegisterID dst)
2279     {
2280         m_formatter.prefix(PRE_SSE_66);
2281         m_formatter.twoByteOp64(OP2_MOVMSKPD_VdEd, dst, (RegisterID)src);
2282     }
2283
2284     void movq_rr(XMMRegisterID src, RegisterID dst)
2285     {
2286         m_formatter.prefix(PRE_SSE_66);
2287         m_formatter.twoByteOp64(OP2_MOVD_EdVd, (RegisterID)src, dst);
2288     }
2289
2290     void movq_rr(RegisterID src, XMMRegisterID dst)
2291     {
2292         m_formatter.prefix(PRE_SSE_66);
2293         m_formatter.twoByteOp64(OP2_MOVD_VdEd, (RegisterID)dst, src);
2294     }
2295 #endif
2296
2297     void movapd_rr(XMMRegisterID src, XMMRegisterID dst)
2298     {
2299         m_formatter.prefix(PRE_SSE_66);
2300         m_formatter.twoByteOp(OP2_MOVAPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2301     }
2302
2303     void movaps_rr(XMMRegisterID src, XMMRegisterID dst)
2304     {
2305         m_formatter.twoByteOp(OP2_MOVAPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
2306     }
2307
2308     void movsd_rr(XMMRegisterID src, XMMRegisterID dst)
2309     {
2310         m_formatter.prefix(PRE_SSE_F2);
2311         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2312     }
2313
2314     void movsd_rm(XMMRegisterID src, int offset, RegisterID base)
2315     {
2316         m_formatter.prefix(PRE_SSE_F2);
2317         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, offset);
2318     }
2319     
2320     void movsd_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
2321     {
2322         m_formatter.prefix(PRE_SSE_F2);
2323         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
2324     }
2325
2326     void movss_rm(XMMRegisterID src, int offset, RegisterID base)
2327     {
2328         m_formatter.prefix(PRE_SSE_F3);
2329         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, offset);
2330     }
2331     
2332     void movss_rm(XMMRegisterID src, int offset, RegisterID base, RegisterID index, int scale)
2333     {
2334         m_formatter.prefix(PRE_SSE_F3);
2335         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, base, index, scale, offset);
2336     }
2337     
2338     void movsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2339     {
2340         m_formatter.prefix(PRE_SSE_F2);
2341         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, base, offset);
2342     }
2343
2344     void movsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2345     {
2346         m_formatter.prefix(PRE_SSE_F2);
2347         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
2348     }
2349
2350     void movss_mr(int offset, RegisterID base, XMMRegisterID dst)
2351     {
2352         m_formatter.prefix(PRE_SSE_F3);
2353         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, base, offset);
2354     }
2355
2356     void movss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2357     {
2358         m_formatter.prefix(PRE_SSE_F3);
2359         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, dst, base, index, scale, offset);
2360     }
2361
2362 #if !CPU(X86_64)
2363     void movsd_mr(const void* address, XMMRegisterID dst)
2364     {
2365         m_formatter.prefix(PRE_SSE_F2);
2366         m_formatter.twoByteOp(OP2_MOVSD_VsdWsd, (RegisterID)dst, address);
2367     }
2368     void movsd_rm(XMMRegisterID src, const void* address)
2369     {
2370         m_formatter.prefix(PRE_SSE_F2);
2371         m_formatter.twoByteOp(OP2_MOVSD_WsdVsd, (RegisterID)src, address);
2372     }
2373 #endif
2374
2375     void mulsd_rr(XMMRegisterID src, XMMRegisterID dst)
2376     {
2377         m_formatter.prefix(PRE_SSE_F2);
2378         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2379     }
2380
2381     void vmulsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2382     {
2383         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2384     }
2385
2386     void mulsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2387     {
2388         m_formatter.prefix(PRE_SSE_F2);
2389         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, base, offset);
2390     }
2391
2392     void mulsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2393     {
2394         m_formatter.prefix(PRE_SSE_F2);
2395         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, dst, base, index, scale, offset);
2396     }
2397
2398     void vmulsd_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2399     {
2400         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2401     }
2402
2403     void vmulsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2404     {
2405         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2406     }
2407
2408     void mulss_rr(XMMRegisterID src, XMMRegisterID dst)
2409     {
2410         m_formatter.prefix(PRE_SSE_F3);
2411         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2412     }
2413
2414     void vmulss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2415     {
2416         m_formatter.vexNdsLigWigCommutativeTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2417     }
2418
2419     void mulss_mr(int offset, RegisterID base, XMMRegisterID dst)
2420     {
2421         m_formatter.prefix(PRE_SSE_F3);
2422         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, (RegisterID)dst, base, offset);
2423     }
2424
2425     void mulss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2426     {
2427         m_formatter.prefix(PRE_SSE_F3);
2428         m_formatter.twoByteOp(OP2_MULSD_VsdWsd, dst, base, index, scale, offset);
2429     }
2430
2431     void vmulss_mr(int offset, RegisterID base, XMMRegisterID b, XMMRegisterID dst)
2432     {
2433         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2434     }
2435
2436     void vmulss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID b, XMMRegisterID dst)
2437     {
2438         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_MULSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2439     }
2440
2441     void pextrw_irr(int whichWord, XMMRegisterID src, RegisterID dst)
2442     {
2443         m_formatter.prefix(PRE_SSE_66);
2444         m_formatter.twoByteOp(OP2_PEXTRW_GdUdIb, (RegisterID)dst, (RegisterID)src);
2445         m_formatter.immediate8(whichWord);
2446     }
2447
2448     void psllq_i8r(int imm, XMMRegisterID dst)
2449     {
2450         m_formatter.prefix(PRE_SSE_66);
2451         m_formatter.twoByteOp8(OP2_PSLLQ_UdqIb, GROUP14_OP_PSLLQ, (RegisterID)dst);
2452         m_formatter.immediate8(imm);
2453     }
2454
2455     void psrlq_i8r(int imm, XMMRegisterID dst)
2456     {
2457         m_formatter.prefix(PRE_SSE_66);
2458         m_formatter.twoByteOp8(OP2_PSRLQ_UdqIb, GROUP14_OP_PSRLQ, (RegisterID)dst);
2459         m_formatter.immediate8(imm);
2460     }
2461
2462     void por_rr(XMMRegisterID src, XMMRegisterID dst)
2463     {
2464         m_formatter.prefix(PRE_SSE_66);
2465         m_formatter.twoByteOp(OP2_POR_VdqWdq, (RegisterID)dst, (RegisterID)src);
2466     }
2467
2468     void subsd_rr(XMMRegisterID src, XMMRegisterID dst)
2469     {
2470         m_formatter.prefix(PRE_SSE_F2);
2471         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2472     }
2473
2474     void vsubsd_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2475     {
2476         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2477     }
2478
2479     void subsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2480     {
2481         m_formatter.prefix(PRE_SSE_F2);
2482         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, base, offset);
2483     }
2484
2485     void subsd_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2486     {
2487         m_formatter.prefix(PRE_SSE_F2);
2488         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, dst, base, index, scale, offset);
2489     }
2490
2491     void vsubsd_mr(XMMRegisterID b, int offset, RegisterID base, XMMRegisterID dst)
2492     {
2493         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2494     }
2495
2496     void vsubsd_mr(XMMRegisterID b, int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2497     {
2498         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F2, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2499     }
2500
2501     void subss_rr(XMMRegisterID src, XMMRegisterID dst)
2502     {
2503         m_formatter.prefix(PRE_SSE_F3);
2504         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2505     }
2506
2507     void vsubss_rr(XMMRegisterID a, XMMRegisterID b, XMMRegisterID dst)
2508     {
2509         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)a, (RegisterID)b);
2510     }
2511
2512     void subss_mr(int offset, RegisterID base, XMMRegisterID dst)
2513     {
2514         m_formatter.prefix(PRE_SSE_F3);
2515         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, (RegisterID)dst, base, offset);
2516     }
2517
2518     void subss_mr(int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2519     {
2520         m_formatter.prefix(PRE_SSE_F3);
2521         m_formatter.twoByteOp(OP2_SUBSD_VsdWsd, dst, base, index, scale, offset);
2522     }
2523
2524     void vsubss_mr(XMMRegisterID b, int offset, RegisterID base, XMMRegisterID dst)
2525     {
2526         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, base, offset);
2527     }
2528
2529     void vsubss_mr(XMMRegisterID b, int offset, RegisterID base, RegisterID index, int scale, XMMRegisterID dst)
2530     {
2531         m_formatter.vexNdsLigWigTwoByteOp(PRE_SSE_F3, OP2_SUBSD_VsdWsd, (RegisterID)dst, (RegisterID)b, offset, base, index, scale);
2532     }
2533
2534     void ucomisd_rr(XMMRegisterID src, XMMRegisterID dst)
2535     {
2536         m_formatter.prefix(PRE_SSE_66);
2537         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2538     }
2539
2540     void ucomisd_mr(int offset, RegisterID base, XMMRegisterID dst)
2541     {
2542         m_formatter.prefix(PRE_SSE_66);
2543         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, base, offset);
2544     }
2545
2546     void ucomiss_rr(XMMRegisterID src, XMMRegisterID dst)
2547     {
2548         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2549     }
2550
2551     void ucomiss_mr(int offset, RegisterID base, XMMRegisterID dst)
2552     {
2553         m_formatter.twoByteOp(OP2_UCOMISD_VsdWsd, (RegisterID)dst, base, offset);
2554     }
2555
2556     void divsd_rr(XMMRegisterID src, XMMRegisterID dst)
2557     {
2558         m_formatter.prefix(PRE_SSE_F2);
2559         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2560     }
2561
2562     void divsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2563     {
2564         m_formatter.prefix(PRE_SSE_F2);
2565         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, base, offset);
2566     }
2567
2568     void divss_rr(XMMRegisterID src, XMMRegisterID dst)
2569     {
2570         m_formatter.prefix(PRE_SSE_F3);
2571         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2572     }
2573
2574     void divss_mr(int offset, RegisterID base, XMMRegisterID dst)
2575     {
2576         m_formatter.prefix(PRE_SSE_F3);
2577         m_formatter.twoByteOp(OP2_DIVSD_VsdWsd, (RegisterID)dst, base, offset);
2578     }
2579
2580     void andps_rr(XMMRegisterID src, XMMRegisterID dst)
2581     {
2582         m_formatter.twoByteOp(OP2_ANDPS_VpdWpd, (RegisterID)dst, (RegisterID)src);
2583     }
2584
2585     void xorps_rr(XMMRegisterID src, XMMRegisterID dst)
2586     {
2587         m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2588     }
2589
2590     void xorpd_rr(XMMRegisterID src, XMMRegisterID dst)
2591     {
2592         if (src == dst) {
2593             xorps_rr(src, dst);
2594             return;
2595         }
2596         m_formatter.prefix(PRE_SSE_66);
2597         m_formatter.twoByteOp(OP2_XORPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2598     }
2599
2600     void andnpd_rr(XMMRegisterID src, XMMRegisterID dst)
2601     {
2602         m_formatter.prefix(PRE_SSE_66);
2603         m_formatter.twoByteOp(OP2_ANDNPD_VpdWpd, (RegisterID)dst, (RegisterID)src);
2604     }
2605
2606     void sqrtsd_rr(XMMRegisterID src, XMMRegisterID dst)
2607     {
2608         m_formatter.prefix(PRE_SSE_F2);
2609         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2610     }
2611
2612     void sqrtsd_mr(int offset, RegisterID base, XMMRegisterID dst)
2613     {
2614         m_formatter.prefix(PRE_SSE_F2);
2615         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, base, offset);
2616     }
2617
2618     void sqrtss_rr(XMMRegisterID src, XMMRegisterID dst)
2619     {
2620         m_formatter.prefix(PRE_SSE_F3);
2621         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, (RegisterID)src);
2622     }
2623
2624     void sqrtss_mr(int offset, RegisterID base, XMMRegisterID dst)
2625     {
2626         m_formatter.prefix(PRE_SSE_F3);
2627         m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, base, offset);
2628     }
2629
2630     enum class RoundingType : uint8_t {
2631         ToNearestWithTiesToEven = 0,
2632         TowardNegativeInfiniti = 1,
2633         TowardInfiniti = 2,
2634         TowardZero = 3
2635     };
2636
2637     void roundss_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
2638     {
2639         m_formatter.prefix(PRE_SSE_66);
2640         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, (RegisterID)src);
2641         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2642     }
2643
2644     void roundss_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
2645     {
2646         m_formatter.prefix(PRE_SSE_66);
2647         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, base, offset);
2648         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2649     }
2650
2651     void roundsd_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
2652     {
2653         m_formatter.prefix(PRE_SSE_66);
2654         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, (RegisterID)src);
2655         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2656     }
2657
2658     void roundsd_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
2659     {
2660         m_formatter.prefix(PRE_SSE_66);
2661         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, base, offset);
2662         m_formatter.immediate8(static_cast<uint8_t>(rounding));
2663     }
2664
2665     // Misc instructions:
2666
2667     void int3()
2668     {
2669         m_formatter.oneByteOp(OP_INT3);
2670     }
2671     
2672     void ret()
2673     {
2674         m_formatter.oneByteOp(OP_RET);
2675     }
2676
2677     void predictNotTaken()
2678     {
2679         m_formatter.prefix(PRE_PREDICT_BRANCH_NOT_TAKEN);
2680     }
2681     
2682     void mfence()
2683     {
2684         m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_AE, OP3_MFENCE);
2685     }
2686
2687     // Assembler admin methods:
2688
2689     size_t codeSize() const
2690     {
2691         return m_formatter.codeSize();
2692     }
2693     
2694     AssemblerLabel labelForWatchpoint()
2695     {
2696         AssemblerLabel result = m_formatter.label();
2697         if (static_cast<int>(result.m_offset) != m_indexOfLastWatchpoint)
2698             result = label();
2699         m_indexOfLastWatchpoint = result.m_offset;
2700         m_indexOfTailOfLastWatchpoint = result.m_offset + maxJumpReplacementSize();
2701         return result;
2702     }
2703     
2704     AssemblerLabel labelIgnoringWatchpoints()
2705     {
2706         return m_formatter.label();
2707     }
2708
2709     AssemblerLabel label()
2710     {
2711         AssemblerLabel result = m_formatter.label();
2712         while (UNLIKELY(static_cast<int>(result.m_offset) < m_indexOfTailOfLastWatchpoint)) {
2713             nop();
2714             result = m_formatter.label();
2715         }
2716         return result;
2717     }
2718
2719     AssemblerLabel align(int alignment)
2720     {
2721         while (!m_formatter.isAligned(alignment))
2722             m_formatter.oneByteOp(OP_HLT);
2723
2724         return label();
2725     }
2726
2727     // Linking & patching:
2728     //
2729     // 'link' and 'patch' methods are for use on unprotected code - such as the code
2730     // within the AssemblerBuffer, and code being patched by the patch buffer.  Once
2731     // code has been finalized it is (platform support permitting) within a non-
2732     // writable region of memory; to modify the code in an execute-only execuable
2733     // pool the 'repatch' and 'relink' methods should be used.
2734
2735     void linkJump(AssemblerLabel from, AssemblerLabel to)
2736     {
2737         ASSERT(from.isSet());
2738         ASSERT(to.isSet());
2739
2740         char* code = reinterpret_cast<char*>(m_formatter.data());
2741         ASSERT(!reinterpret_cast<int32_t*>(code + from.m_offset)[-1]);
2742         setRel32(code + from.m_offset, code + to.m_offset);
2743     }
2744     
2745     static void linkJump(void* code, AssemblerLabel from, void* to)
2746     {
2747         ASSERT(from.isSet());
2748
2749         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2750     }
2751
2752     static void linkCall(void* code, AssemblerLabel from, void* to)
2753     {
2754         ASSERT(from.isSet());
2755
2756         setRel32(reinterpret_cast<char*>(code) + from.m_offset, to);
2757     }
2758
2759     static void linkPointer(void* code, AssemblerLabel where, void* value)
2760     {
2761         ASSERT(where.isSet());
2762
2763         setPointer(reinterpret_cast<char*>(code) + where.m_offset, value);
2764     }
2765
2766     static void relinkJump(void* from, void* to)
2767     {
2768         setRel32(from, to);
2769     }
2770     
2771     static void relinkCall(void* from, void* to)
2772     {
2773         setRel32(from, to);
2774     }
2775     
2776     static void repatchCompact(void* where, int32_t value)
2777     {
2778         ASSERT(value >= std::numeric_limits<int8_t>::min());
2779         ASSERT(value <= std::numeric_limits<int8_t>::max());
2780         setInt8(where, value);
2781     }
2782
2783     static void repatchInt32(void* where, int32_t value)
2784     {
2785         setInt32(where, value);
2786     }
2787
2788     static void repatchPointer(void* where, void* value)
2789     {
2790         setPointer(where, value);
2791     }
2792     
2793     static void* readPointer(void* where)
2794     {
2795         return reinterpret_cast<void**>(where)[-1];
2796     }
2797
2798     static void replaceWithJump(void* instructionStart, void* to)
2799     {
2800         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2801         uint8_t* dstPtr = reinterpret_cast<uint8_t*>(to);
2802         intptr_t distance = (intptr_t)(dstPtr - (ptr + 5));
2803         ptr[0] = static_cast<uint8_t>(OP_JMP_rel32);
2804         *reinterpret_cast<int32_t*>(ptr + 1) = static_cast<int32_t>(distance);
2805     }
2806     
2807     static ptrdiff_t maxJumpReplacementSize()
2808     {
2809         return 5;
2810     }
2811     
2812 #if CPU(X86_64)
2813     static void revertJumpTo_movq_i64r(void* instructionStart, int64_t imm, RegisterID dst)
2814     {
2815         const unsigned instructionSize = 10; // REX.W MOV IMM64
2816         const int rexBytes = 1;
2817         const int opcodeBytes = 1;
2818         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2819         ptr[0] = PRE_REX | (1 << 3) | (dst >> 3);
2820         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2821         
2822         union {
2823             uint64_t asWord;
2824             uint8_t asBytes[8];
2825         } u;
2826         u.asWord = imm;
2827         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2828             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2829     }
2830
2831     static void revertJumpTo_movl_i32r(void* instructionStart, int32_t imm, RegisterID dst)
2832     {
2833         // We only revert jumps on inline caches, and inline caches always use the scratch register (r11).
2834         // FIXME: If the above is ever false then we need to make this smarter with respect to emitting 
2835         // the REX byte.
2836         ASSERT(dst == X86Registers::r11);
2837         const unsigned instructionSize = 6; // REX MOV IMM32
2838         const int rexBytes = 1;
2839         const int opcodeBytes = 1;
2840         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2841         ptr[0] = PRE_REX | (dst >> 3);
2842         ptr[1] = OP_MOV_EAXIv | (dst & 7);
2843         
2844         union {
2845             uint32_t asWord;
2846             uint8_t asBytes[4];
2847         } u;
2848         u.asWord = imm;
2849         for (unsigned i = rexBytes + opcodeBytes; i < instructionSize; ++i)
2850             ptr[i] = u.asBytes[i - rexBytes - opcodeBytes];
2851     }
2852 #endif
2853
2854     static void revertJumpTo_cmpl_ir_force32(void* instructionStart, int32_t imm, RegisterID dst)
2855     {
2856         const int opcodeBytes = 1;
2857         const int modRMBytes = 1;
2858         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2859         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2860         ptr[0] = OP_GROUP1_EvIz;
2861         ptr[1] = (X86InstructionFormatter::ModRmRegister << 6) | (GROUP1_OP_CMP << 3) | dst;
2862         union {
2863             uint32_t asWord;
2864             uint8_t asBytes[4];
2865         } u;
2866         u.asWord = imm;
2867         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2868             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2869     }
2870     
2871     static void revertJumpTo_cmpl_im_force32(void* instructionStart, int32_t imm, int offset, RegisterID dst)
2872     {
2873         ASSERT_UNUSED(offset, !offset);
2874         const int opcodeBytes = 1;
2875         const int modRMBytes = 1;
2876         ASSERT(opcodeBytes + modRMBytes <= maxJumpReplacementSize());
2877         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2878         ptr[0] = OP_GROUP1_EvIz;
2879         ptr[1] = (X86InstructionFormatter::ModRmMemoryNoDisp << 6) | (GROUP1_OP_CMP << 3) | dst;
2880         union {
2881             uint32_t asWord;
2882             uint8_t asBytes[4];
2883         } u;
2884         u.asWord = imm;
2885         for (unsigned i = opcodeBytes + modRMBytes; i < static_cast<unsigned>(maxJumpReplacementSize()); ++i)
2886             ptr[i] = u.asBytes[i - opcodeBytes - modRMBytes];
2887     }
2888     
2889     static void replaceWithLoad(void* instructionStart)
2890     {
2891         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2892 #if CPU(X86_64)
2893         if ((*ptr & ~15) == PRE_REX)
2894             ptr++;
2895 #endif
2896         switch (*ptr) {
2897         case OP_MOV_GvEv:
2898             break;
2899         case OP_LEA:
2900             *ptr = OP_MOV_GvEv;
2901             break;
2902         default:
2903             RELEASE_ASSERT_NOT_REACHED();
2904         }
2905     }
2906     
2907     static void replaceWithAddressComputation(void* instructionStart)
2908     {
2909         uint8_t* ptr = reinterpret_cast<uint8_t*>(instructionStart);
2910 #if CPU(X86_64)
2911         if ((*ptr & ~15) == PRE_REX)
2912             ptr++;
2913 #endif
2914         switch (*ptr) {
2915         case OP_MOV_GvEv:
2916             *ptr = OP_LEA;
2917             break;
2918         case OP_LEA:
2919             break;
2920         default:
2921             RELEASE_ASSERT_NOT_REACHED();
2922         }
2923     }
2924     
2925     static unsigned getCallReturnOffset(AssemblerLabel call)
2926     {
2927         ASSERT(call.isSet());
2928         return call.m_offset;
2929     }
2930
2931     static void* getRelocatedAddress(void* code, AssemblerLabel label)
2932     {
2933         ASSERT(label.isSet());
2934         return reinterpret_cast<void*>(reinterpret_cast<ptrdiff_t>(code) + label.m_offset);
2935     }
2936     
2937     static int getDifferenceBetweenLabels(AssemblerLabel a, AssemblerLabel b)
2938     {
2939         return b.m_offset - a.m_offset;
2940     }
2941     
2942     unsigned debugOffset() { return m_formatter.debugOffset(); }
2943
2944     void nop()
2945     {
2946         m_formatter.oneByteOp(OP_NOP);
2947     }
2948
2949     static void fillNops(void* base, size_t size)
2950     {
2951 #if CPU(X86_64)
2952         static const uint8_t nops[10][10] = {
2953             // nop
2954             {0x90},
2955             // xchg %ax,%ax
2956             {0x66, 0x90},
2957             // nopl (%[re]ax)
2958             {0x0f, 0x1f, 0x00},
2959             // nopl 8(%[re]ax)
2960             {0x0f, 0x1f, 0x40, 0x08},
2961             // nopl 8(%[re]ax,%[re]ax,1)
2962             {0x0f, 0x1f, 0x44, 0x00, 0x08},
2963             // nopw 8(%[re]ax,%[re]ax,1)
2964             {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x08},
2965             // nopl 512(%[re]ax)
2966             {0x0f, 0x1f, 0x80, 0x00, 0x02, 0x00, 0x00},
2967             // nopl 512(%[re]ax,%[re]ax,1)
2968             {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00},
2969             // nopw 512(%[re]ax,%[re]ax,1)
2970             {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00},
2971             // nopw %cs:512(%[re]ax,%[re]ax,1)
2972             {0x66, 0x2e, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x02, 0x00, 0x00}
2973         };
2974
2975         uint8_t* where = reinterpret_cast<uint8_t*>(base);
2976         while (size) {
2977             unsigned nopSize = static_cast<unsigned>(std::min<size_t>(size, 15));
2978             unsigned numPrefixes = nopSize <= 10 ? 0 : nopSize - 10;
2979             for (unsigned i = 0; i != numPrefixes; ++i)
2980                 *where++ = 0x66;
2981
2982             unsigned nopRest = nopSize - numPrefixes;
2983             for (unsigned i = 0; i != nopRest; ++i)
2984                 *where++ = nops[nopRest-1][i];
2985
2986             size -= nopSize;
2987         }
2988 #else
2989         memset(base, OP_NOP, size);
2990 #endif
2991     }
2992
2993     // This is a no-op on x86
2994     ALWAYS_INLINE static void cacheFlush(void*, size_t) { }
2995
2996 private:
2997
2998     static void setPointer(void* where, void* value)
2999     {
3000         reinterpret_cast<void**>(where)[-1] = value;
3001     }
3002
3003     static void setInt32(void* where, int32_t value)
3004     {
3005         reinterpret_cast<int32_t*>(where)[-1] = value;
3006     }
3007     
3008     static void setInt8(void* where, int8_t value)
3009     {
3010         reinterpret_cast<int8_t*>(where)[-1] = value;
3011     }
3012
3013     static void setRel32(void* from, void* to)
3014     {
3015         intptr_t offset = reinterpret_cast<intptr_t>(to) - reinterpret_cast<intptr_t>(from);
3016         ASSERT(offset == static_cast<int32_t>(offset));
3017
3018         setInt32(from, offset);
3019     }
3020
3021     class X86InstructionFormatter {
3022         static const int maxInstructionSize = 16;
3023
3024     public:
3025         enum ModRmMode {
3026             ModRmMemoryNoDisp = 0,
3027             ModRmMemoryDisp8 = 1 << 6,
3028             ModRmMemoryDisp32 = 2 << 6,
3029             ModRmRegister = 3 << 6,
3030         };
3031
3032         // Legacy prefix bytes:
3033         //
3034         // These are emmitted prior to the instruction.
3035
3036         void prefix(OneByteOpcodeID pre)
3037         {
3038             m_buffer.putByte(pre);
3039         }
3040
3041 #if CPU(X86_64)
3042         // Byte operand register spl & above require a REX prefix (to prevent the 'H' registers be accessed).
3043         static bool byteRegRequiresRex(int reg)
3044         {
3045             static_assert(X86Registers::esp == 4, "Necessary condition for OR-masking");
3046             return (reg >= X86Registers::esp);
3047         }
3048         static bool byteRegRequiresRex(int a, int b)
3049         {
3050             return byteRegRequiresRex(a | b);
3051         }
3052
3053         // Registers r8 & above require a REX prefixe.
3054         static bool regRequiresRex(int reg)
3055         {
3056             static_assert(X86Registers::r8 == 8, "Necessary condition for OR-masking");
3057             return (reg >= X86Registers::r8);
3058         }
3059         static bool regRequiresRex(int a, int b)
3060         {
3061             return regRequiresRex(a | b);
3062         }
3063         static bool regRequiresRex(int a, int b, int c)
3064         {
3065             return regRequiresRex(a | b | c);
3066         }
3067 #else
3068         static bool byteRegRequiresRex(int) { return false; }
3069         static bool byteRegRequiresRex(int, int) { return false; }
3070         static bool regRequiresRex(int) { return false; }
3071         static bool regRequiresRex(int, int) { return false; }
3072         static bool regRequiresRex(int, int, int) { return false; }
3073 #endif
3074
3075         class SingleInstructionBufferWriter : public AssemblerBuffer::LocalWriter {
3076         public:
3077             SingleInstructionBufferWriter(AssemblerBuffer& buffer)
3078                 : AssemblerBuffer::LocalWriter(buffer, maxInstructionSize)
3079             {
3080             }
3081
3082             // Internals; ModRm and REX formatters.
3083
3084             static constexpr RegisterID noBase = X86Registers::ebp;
3085             static constexpr RegisterID hasSib = X86Registers::esp;
3086             static constexpr RegisterID noIndex = X86Registers::esp;
3087
3088 #if CPU(X86_64)
3089             static constexpr RegisterID noBase2 = X86Registers::r13;
3090             static constexpr RegisterID hasSib2 = X86Registers::r12;
3091
3092             // Format a REX prefix byte.
3093             ALWAYS_INLINE void emitRex(bool w, int r, int x, int b)
3094             {
3095                 ASSERT(r >= 0);
3096                 ASSERT(x >= 0);
3097                 ASSERT(b >= 0);
3098                 putByteUnchecked(PRE_REX | ((int)w << 3) | ((r>>3)<<2) | ((x>>3)<<1) | (b>>3));
3099             }
3100
3101             // Used to plant a REX byte with REX.w set (for 64-bit operations).
3102             ALWAYS_INLINE void emitRexW(int r, int x, int b)
3103             {
3104                 emitRex(true, r, x, b);
3105             }
3106
3107             // Used for operations with byte operands - use byteRegRequiresRex() to check register operands,
3108             // regRequiresRex() to check other registers (i.e. address base & index).
3109             ALWAYS_INLINE void emitRexIf(bool condition, int r, int x, int b)
3110             {
3111                 if (condition)
3112                     emitRex(false, r, x, b);
3113             }
3114
3115             // Used for word sized operations, will plant a REX prefix if necessary (if any register is r8 or above).
3116             ALWAYS_INLINE void emitRexIfNeeded(int r, int x, int b)
3117             {
3118                 emitRexIf(regRequiresRex(r, x, b), r, x, b);
3119             }
3120 #else
3121             // No REX prefix bytes on 32-bit x86.
3122             ALWAYS_INLINE void emitRexIf(bool, int, int, int) { }
3123             ALWAYS_INLINE void emitRexIfNeeded(int, int, int) { }
3124 #endif
3125
3126             ALWAYS_INLINE void putModRm(ModRmMode mode, int reg, RegisterID rm)
3127             {
3128                 putByteUnchecked(mode | ((reg & 7) << 3) | (rm & 7));
3129             }
3130
3131             ALWAYS_INLINE void putModRmSib(ModRmMode mode, int reg, RegisterID base, RegisterID index, int scale)
3132             {
3133                 ASSERT(mode != ModRmRegister);
3134
3135                 putModRm(mode, reg, hasSib);
3136                 putByteUnchecked((scale << 6) | ((index & 7) << 3) | (base & 7));
3137             }
3138
3139             ALWAYS_INLINE void registerModRM(int reg, RegisterID rm)
3140             {
3141                 putModRm(ModRmRegister, reg, rm);
3142             }
3143
3144             ALWAYS_INLINE void memoryModRM(int reg, RegisterID base, int offset)
3145             {
3146                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3147 #if CPU(X86_64)
3148                 if ((base == hasSib) || (base == hasSib2)) {
3149 #else
3150                 if (base == hasSib) {
3151 #endif
3152                     if (!offset) // No need to check if the base is noBase, since we know it is hasSib!
3153                         putModRmSib(ModRmMemoryNoDisp, reg, base, noIndex, 0);
3154                     else if (CAN_SIGN_EXTEND_8_32(offset)) {
3155                         putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
3156                         putByteUnchecked(offset);
3157                     } else {
3158                         putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
3159                         putIntUnchecked(offset);
3160                     }
3161                 } else {
3162 #if CPU(X86_64)
3163                     if (!offset && (base != noBase) && (base != noBase2))
3164 #else
3165                     if (!offset && (base != noBase))
3166 #endif
3167                         putModRm(ModRmMemoryNoDisp, reg, base);
3168                     else if (CAN_SIGN_EXTEND_8_32(offset)) {
3169                         putModRm(ModRmMemoryDisp8, reg, base);
3170                         putByteUnchecked(offset);
3171                     } else {
3172                         putModRm(ModRmMemoryDisp32, reg, base);
3173                         putIntUnchecked(offset);
3174                     }
3175                 }
3176             }
3177
3178             ALWAYS_INLINE void memoryModRM_disp8(int reg, RegisterID base, int offset)
3179             {
3180                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3181                 ASSERT(CAN_SIGN_EXTEND_8_32(offset));
3182 #if CPU(X86_64)
3183                 if ((base == hasSib) || (base == hasSib2)) {
3184 #else
3185                 if (base == hasSib) {
3186 #endif
3187                     putModRmSib(ModRmMemoryDisp8, reg, base, noIndex, 0);
3188                     putByteUnchecked(offset);
3189                 } else {
3190                     putModRm(ModRmMemoryDisp8, reg, base);
3191                     putByteUnchecked(offset);
3192                 }
3193             }
3194
3195             ALWAYS_INLINE void memoryModRM_disp32(int reg, RegisterID base, int offset)
3196             {
3197                 // A base of esp or r12 would be interpreted as a sib, so force a sib with no index & put the base in there.
3198 #if CPU(X86_64)
3199                 if ((base == hasSib) || (base == hasSib2)) {
3200 #else
3201                 if (base == hasSib) {
3202 #endif
3203                     putModRmSib(ModRmMemoryDisp32, reg, base, noIndex, 0);
3204                     putIntUnchecked(offset);
3205                 } else {
3206                     putModRm(ModRmMemoryDisp32, reg, base);
3207                     putIntUnchecked(offset);
3208                 }
3209             }
3210         
3211             ALWAYS_INLINE void memoryModRM(int reg, RegisterID base, RegisterID index, int scale, int offset)
3212             {
3213                 ASSERT(index != noIndex);
3214
3215 #if CPU(X86_64)
3216                 if (!offset && (base != noBase) && (base != noBase2))
3217 #else
3218                 if (!offset && (base != noBase))
3219 #endif
3220                     putModRmSib(ModRmMemoryNoDisp, reg, base, index, scale);
3221                 else if (CAN_SIGN_EXTEND_8_32(offset)) {
3222                     putModRmSib(ModRmMemoryDisp8, reg, base, index, scale);
3223                     putByteUnchecked(offset);
3224                 } else {
3225                     putModRmSib(ModRmMemoryDisp32, reg, base, index, scale);
3226                     putIntUnchecked(offset);
3227                 }
3228             }
3229
3230 #if !CPU(X86_64)
3231             ALWAYS_INLINE void memoryModRM(int reg, const void* address)
3232             {
3233                 // noBase + ModRmMemoryNoDisp means noBase + ModRmMemoryDisp32!
3234                 putModRm(ModRmMemoryNoDisp, reg, noBase);
3235                 putIntUnchecked(reinterpret_cast<int32_t>(address));
3236             }
3237 #endif
3238             ALWAYS_INLINE void twoBytesVex(OneByteOpcodeID simdPrefix, RegisterID inOpReg, RegisterID r)
3239             {
3240                 putByteUnchecked(VexPrefix::TwoBytes);
3241
3242                 uint8_t secondByte = vexEncodeSimdPrefix(simdPrefix);
3243                 secondByte |= (~inOpReg & 0xf) << 3;
3244                 secondByte |= !regRequiresRex(r) << 7;
3245                 putByteUnchecked(secondByte);
3246             }
3247
3248             ALWAYS_INLINE void threeBytesVexNds(OneByteOpcodeID simdPrefix, VexImpliedBytes impliedBytes, RegisterID r, RegisterID inOpReg, RegisterID x, RegisterID b)
3249             {
3250                 putByteUnchecked(VexPrefix::ThreeBytes);
3251
3252                 uint8_t secondByte = static_cast<uint8_t>(impliedBytes);
3253                 secondByte |= !regRequiresRex(r) << 7;
3254                 secondByte |= !regRequiresRex(x) << 6;
3255                 secondByte |= !regRequiresRex(b) << 5;
3256                 putByteUnchecked(secondByte);
3257
3258                 uint8_t thirdByte = vexEncodeSimdPrefix(simdPrefix);
3259                 thirdByte |= (~inOpReg & 0xf) << 3;
3260                 putByteUnchecked(thirdByte);
3261             }
3262
3263             ALWAYS_INLINE void threeBytesVexNds(OneByteOpcodeID simdPrefix, VexImpliedBytes impliedBytes, RegisterID r, RegisterID inOpReg, RegisterID b)
3264             {
3265                 putByteUnchecked(VexPrefix::ThreeBytes);
3266
3267                 uint8_t secondByte = static_cast<uint8_t>(impliedBytes);
3268                 secondByte |= !regRequiresRex(r) << 7;
3269                 secondByte |= 1 << 6; // REX.X
3270                 secondByte |= !regRequiresRex(b) << 5;
3271                 putByteUnchecked(secondByte);
3272
3273                 uint8_t thirdByte = vexEncodeSimdPrefix(simdPrefix);
3274                 thirdByte |= (~inOpReg & 0xf) << 3;
3275                 putByteUnchecked(thirdByte);
3276             }
3277         private:
3278             uint8_t vexEncodeSimdPrefix(OneByteOpcodeID simdPrefix)
3279             {
3280                 switch (simdPrefix) {
3281                 case 0x66:
3282                     return 1;
3283                 case 0xF3:
3284                     return 2;
3285                 case 0xF2:
3286                     return 3;
3287                 default:
3288                     RELEASE_ASSERT_NOT_REACHED();
3289                 }
3290                 return 0;
3291             }
3292
3293         };
3294
3295         // Word-sized operands / no operand instruction formatters.
3296         //
3297         // In addition to the opcode, the following operand permutations are supported:
3298         //   * None - instruction takes no operands.
3299         //   * One register - the low three bits of the RegisterID are added into the opcode.
3300         //   * 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).
3301         //   * Three argument ModRM - a register, and a register and an offset describing a memory operand.
3302         //   * Five argument ModRM - a register, and a base register, an index, scale, and offset describing a memory operand.
3303         //
3304         // For 32-bit x86 targets, the address operand may also be provided as a void*.
3305         // On 64-bit targets REX prefixes will be planted as necessary, where high numbered registers are used.
3306         //
3307         // The twoByteOp methods plant two-byte Intel instructions sequences (first opcode byte 0x0F).
3308
3309         void oneByteOp(OneByteOpcodeID opcode)
3310         {
3311             SingleInstructionBufferWriter writer(m_buffer);
3312             writer.putByteUnchecked(opcode);
3313         }
3314
3315         void oneByteOp(OneByteOpcodeID opcode, RegisterID reg)
3316         {
3317             SingleInstructionBufferWriter writer(m_buffer);
3318             writer.emitRexIfNeeded(0, 0, reg);
3319             writer.putByteUnchecked(opcode + (reg & 7));
3320         }
3321
3322         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID rm)
3323         {
3324             SingleInstructionBufferWriter writer(m_buffer);
3325             writer.emitRexIfNeeded(reg, 0, rm);
3326             writer.putByteUnchecked(opcode);
3327             writer.registerModRM(reg, rm);
3328         }
3329
3330         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3331         {
3332             SingleInstructionBufferWriter writer(m_buffer);
3333             writer.emitRexIfNeeded(reg, 0, base);
3334             writer.putByteUnchecked(opcode);
3335             writer.memoryModRM(reg, base, offset);
3336         }
3337
3338         void oneByteOp_disp32(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3339         {
3340             SingleInstructionBufferWriter writer(m_buffer);
3341             writer.emitRexIfNeeded(reg, 0, base);
3342             writer.putByteUnchecked(opcode);
3343             writer.memoryModRM_disp32(reg, base, offset);
3344         }
3345         
3346         void oneByteOp_disp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3347         {
3348             SingleInstructionBufferWriter writer(m_buffer);
3349             writer.emitRexIfNeeded(reg, 0, base);
3350             writer.putByteUnchecked(opcode);
3351             writer.memoryModRM_disp8(reg, base, offset);
3352         }
3353
3354         void oneByteOp(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3355         {
3356             SingleInstructionBufferWriter writer(m_buffer);
3357             writer.emitRexIfNeeded(reg, index, base);
3358             writer.putByteUnchecked(opcode);
3359             writer.memoryModRM(reg, base, index, scale, offset);
3360         }
3361
3362 #if !CPU(X86_64)
3363         void oneByteOp(OneByteOpcodeID opcode, int reg, const void* address)
3364         {
3365             SingleInstructionBufferWriter writer(m_buffer);
3366             writer.putByteUnchecked(opcode);
3367             writer.memoryModRM(reg, address);
3368         }
3369 #endif
3370
3371         void twoByteOp(TwoByteOpcodeID opcode)
3372         {
3373             SingleInstructionBufferWriter writer(m_buffer);
3374             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3375             writer.putByteUnchecked(opcode);
3376         }
3377
3378         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID rm)
3379         {
3380             SingleInstructionBufferWriter writer(m_buffer);
3381             writer.emitRexIfNeeded(reg, 0, rm);
3382             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3383             writer.putByteUnchecked(opcode);
3384             writer.registerModRM(reg, rm);
3385         }
3386
3387         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID base, int offset)
3388         {
3389             SingleInstructionBufferWriter writer(m_buffer);
3390             writer.emitRexIfNeeded(reg, 0, base);
3391             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3392             writer.putByteUnchecked(opcode);
3393             writer.memoryModRM(reg, base, offset);
3394         }
3395
3396         void twoByteOp(TwoByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3397         {
3398             SingleInstructionBufferWriter writer(m_buffer);
3399             writer.emitRexIfNeeded(reg, index, base);
3400             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3401             writer.putByteUnchecked(opcode);
3402             writer.memoryModRM(reg, base, index, scale, offset);
3403         }
3404
3405 #if !CPU(X86_64)
3406         void twoByteOp(TwoByteOpcodeID opcode, int reg, const void* address)
3407         {
3408             SingleInstructionBufferWriter writer(m_buffer);
3409             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3410             writer.putByteUnchecked(opcode);
3411             writer.memoryModRM(reg, address);
3412         }
3413 #endif
3414         void vexNdsLigWigTwoByteOp(OneByteOpcodeID simdPrefix, TwoByteOpcodeID opcode, RegisterID dest, RegisterID a, RegisterID b)
3415         {
3416             SingleInstructionBufferWriter writer(m_buffer);
3417             if (regRequiresRex(b))
3418                 writer.threeBytesVexNds(simdPrefix, VexImpliedBytes::TwoBytesOp, dest, a, b);
3419             else
3420                 writer.twoBytesVex(simdPrefix, a, dest);
3421             writer.putByteUnchecked(opcode);
3422             writer.registerModRM(dest, b);
3423         }
3424
3425         void vexNdsLigWigCommutativeTwoByteOp(OneByteOpcodeID simdPrefix, TwoByteOpcodeID opcode, RegisterID dest, RegisterID a, RegisterID b)
3426         {
3427             // Since this is a commutative operation, we can try switching the arguments.
3428             if (regRequiresRex(b))
3429                 std::swap(a, b);
3430             vexNdsLigWigTwoByteOp(simdPrefix, opcode, dest, a, b);
3431         }
3432
3433         void vexNdsLigWigTwoByteOp(OneByteOpcodeID simdPrefix, TwoByteOpcodeID opcode, RegisterID dest, RegisterID a, RegisterID base, int offset)
3434         {
3435             SingleInstructionBufferWriter writer(m_buffer);
3436             if (regRequiresRex(base))
3437                 writer.threeBytesVexNds(simdPrefix, VexImpliedBytes::TwoBytesOp, dest, a, base);
3438             else
3439                 writer.twoBytesVex(simdPrefix, a, dest);
3440             writer.putByteUnchecked(opcode);
3441             writer.memoryModRM(dest, base, offset);
3442         }
3443
3444         void vexNdsLigWigTwoByteOp(OneByteOpcodeID simdPrefix, TwoByteOpcodeID opcode, RegisterID dest, RegisterID a, int offset, RegisterID base, RegisterID index, int scale)
3445         {
3446             SingleInstructionBufferWriter writer(m_buffer);
3447             if (regRequiresRex(base, index))
3448                 writer.threeBytesVexNds(simdPrefix, VexImpliedBytes::TwoBytesOp, dest, a, index, base);
3449             else
3450                 writer.twoBytesVex(simdPrefix, a, dest);
3451             writer.putByteUnchecked(opcode);
3452             writer.memoryModRM(dest, base, index, scale, offset);
3453         }
3454
3455         void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode)
3456         {
3457             SingleInstructionBufferWriter writer(m_buffer);
3458             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3459             writer.putByteUnchecked(twoBytePrefix);
3460             writer.putByteUnchecked(opcode);
3461         }
3462
3463         void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode, int reg, RegisterID rm)
3464         {
3465             SingleInstructionBufferWriter writer(m_buffer);
3466             writer.emitRexIfNeeded(reg, 0, rm);
3467             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3468             writer.putByteUnchecked(twoBytePrefix);
3469             writer.putByteUnchecked(opcode);
3470             writer.registerModRM(reg, rm);
3471         }
3472
3473         void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode, int reg, RegisterID base, int displacement)
3474         {
3475             SingleInstructionBufferWriter writer(m_buffer);
3476             writer.emitRexIfNeeded(reg, 0, base);
3477             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3478             writer.putByteUnchecked(twoBytePrefix);
3479             writer.putByteUnchecked(opcode);
3480             writer.memoryModRM(reg, base, displacement);
3481         }
3482
3483 #if CPU(X86_64)
3484         // Quad-word-sized operands:
3485         //
3486         // Used to format 64-bit operantions, planting a REX.w prefix.
3487         // When planting d64 or f64 instructions, not requiring a REX.w prefix,
3488         // the normal (non-'64'-postfixed) formatters should be used.
3489
3490         void oneByteOp64(OneByteOpcodeID opcode)
3491         {
3492             SingleInstructionBufferWriter writer(m_buffer);
3493             writer.emitRexW(0, 0, 0);
3494             writer.putByteUnchecked(opcode);
3495         }
3496
3497         void oneByteOp64(OneByteOpcodeID opcode, RegisterID reg)
3498         {
3499             SingleInstructionBufferWriter writer(m_buffer);
3500             writer.emitRexW(0, 0, reg);
3501             writer.putByteUnchecked(opcode + (reg & 7));
3502         }
3503
3504         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID rm)
3505         {
3506             SingleInstructionBufferWriter writer(m_buffer);
3507             writer.emitRexW(reg, 0, rm);
3508             writer.putByteUnchecked(opcode);
3509             writer.registerModRM(reg, rm);
3510         }
3511
3512         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3513         {
3514             SingleInstructionBufferWriter writer(m_buffer);
3515             writer.emitRexW(reg, 0, base);
3516             writer.putByteUnchecked(opcode);
3517             writer.memoryModRM(reg, base, offset);
3518         }
3519
3520         void oneByteOp64_disp32(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3521         {
3522             SingleInstructionBufferWriter writer(m_buffer);
3523             writer.emitRexW(reg, 0, base);
3524             writer.putByteUnchecked(opcode);
3525             writer.memoryModRM_disp32(reg, base, offset);
3526         }
3527         
3528         void oneByteOp64_disp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3529         {
3530             SingleInstructionBufferWriter writer(m_buffer);
3531             writer.emitRexW(reg, 0, base);
3532             writer.putByteUnchecked(opcode);
3533             writer.memoryModRM_disp8(reg, base, offset);
3534         }
3535
3536         void oneByteOp64(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3537         {
3538             SingleInstructionBufferWriter writer(m_buffer);
3539             writer.emitRexW(reg, index, base);
3540             writer.putByteUnchecked(opcode);
3541             writer.memoryModRM(reg, base, index, scale, offset);
3542         }
3543
3544         void twoByteOp64(TwoByteOpcodeID opcode, int reg, RegisterID rm)
3545         {
3546             SingleInstructionBufferWriter writer(m_buffer);
3547             writer.emitRexW(reg, 0, rm);
3548             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3549             writer.putByteUnchecked(opcode);
3550             writer.registerModRM(reg, rm);
3551         }
3552
3553         void twoByteOp64(TwoByteOpcodeID opcode, int reg, RegisterID base, int offset)
3554         {
3555             SingleInstructionBufferWriter writer(m_buffer);
3556             writer.emitRexW(reg, 0, base);
3557             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3558             writer.putByteUnchecked(opcode);
3559             writer.memoryModRM(reg, base, offset);
3560         }
3561
3562         void twoByteOp64(TwoByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3563         {
3564             SingleInstructionBufferWriter writer(m_buffer);
3565             writer.emitRexW(reg, index, base);
3566             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3567             writer.putByteUnchecked(opcode);
3568             writer.memoryModRM(reg, base, index, scale, offset);
3569         }
3570 #endif
3571
3572         // Byte-operands:
3573         //
3574         // These methods format byte operations.  Byte operations differ from the normal
3575         // formatters in the circumstances under which they will decide to emit REX prefixes.
3576         // These should be used where any register operand signifies a byte register.
3577         //
3578         // The disctinction is due to the handling of register numbers in the range 4..7 on
3579         // x86-64.  These register numbers may either represent the second byte of the first
3580         // four registers (ah..bh) or the first byte of the second four registers (spl..dil).
3581         //
3582         // Since ah..bh cannot be used in all permutations of operands (specifically cannot
3583         // be accessed where a REX prefix is present), these are likely best treated as
3584         // deprecated.  In order to ensure the correct registers spl..dil are selected a
3585         // REX prefix will be emitted for any byte register operand in the range 4..15.
3586         //
3587         // These formatters may be used in instructions where a mix of operand sizes, in which
3588         // case an unnecessary REX will be emitted, for example:
3589         //     movzbl %al, %edi
3590         // In this case a REX will be planted since edi is 7 (and were this a byte operand
3591         // a REX would be required to specify dil instead of bh).  Unneeded REX prefixes will
3592         // be silently ignored by the processor.
3593         //
3594         // Address operands should still be checked using regRequiresRex(), while byteRegRequiresRex()
3595         // is provided to check byte register operands.
3596
3597         void oneByteOp8(OneByteOpcodeID opcode, GroupOpcodeID groupOp, RegisterID rm)
3598         {
3599             SingleInstructionBufferWriter writer(m_buffer);
3600             writer.emitRexIf(byteRegRequiresRex(rm), 0, 0, rm);
3601             writer.putByteUnchecked(opcode);
3602             writer.registerModRM(groupOp, rm);
3603         }
3604
3605         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID rm)
3606         {
3607             SingleInstructionBufferWriter writer(m_buffer);
3608             writer.emitRexIf(byteRegRequiresRex(reg, rm), reg, 0, rm);
3609             writer.putByteUnchecked(opcode);
3610             writer.registerModRM(reg, rm);
3611         }
3612
3613         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID base, int offset)
3614         {
3615             SingleInstructionBufferWriter writer(m_buffer);
3616             writer.emitRexIf(byteRegRequiresRex(reg, base), reg, 0, base);
3617             writer.putByteUnchecked(opcode);
3618             writer.memoryModRM(reg, base, offset);
3619         }
3620
3621         void oneByteOp8(OneByteOpcodeID opcode, int reg, RegisterID base, RegisterID index, int scale, int offset)
3622         {
3623             SingleInstructionBufferWriter writer(m_buffer);
3624             writer.emitRexIf(byteRegRequiresRex(reg) || regRequiresRex(index, base), reg, index, base);
3625             writer.putByteUnchecked(opcode);
3626             writer.memoryModRM(reg, base, index, scale, offset);
3627         }
3628
3629         void twoByteOp8(TwoByteOpcodeID opcode, RegisterID reg, RegisterID rm)
3630         {
3631             SingleInstructionBufferWriter writer(m_buffer);
3632             writer.emitRexIf(byteRegRequiresRex(reg, rm), reg, 0, rm);
3633             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3634             writer.putByteUnchecked(opcode);
3635             writer.registerModRM(reg, rm);
3636         }
3637
3638         void twoByteOp8(TwoByteOpcodeID opcode, GroupOpcodeID groupOp, RegisterID rm)
3639         {
3640             SingleInstructionBufferWriter writer(m_buffer);
3641             writer.emitRexIf(byteRegRequiresRex(rm), 0, 0, rm);
3642             writer.putByteUnchecked(OP_2BYTE_ESCAPE);
3643             writer.putByteUnchecked(opcode);
3644             writer.registerModRM(groupOp, rm);
3645         }
3646
3647         // Immediates:
3648         //
3649         // An immedaite should be appended where appropriate after an op has been emitted.
3650         // The writes are unchecked since the opcode formatters above will have ensured space.
3651
3652         void immediate8(int imm)
3653         {
3654             m_buffer.putByteUnchecked(imm);
3655         }
3656
3657         void immediate16(int imm)
3658         {
3659             m_buffer.putShortUnchecked(imm);
3660         }
3661
3662         void immediate32(int imm)
3663         {
3664             m_buffer.putIntUnchecked(imm);
3665         }
3666
3667         void immediate64(int64_t imm)
3668         {
3669             m_buffer.putInt64Unchecked(imm);
3670         }
3671
3672         AssemblerLabel immediateRel32()
3673         {
3674             m_buffer.putIntUnchecked(0);
3675             return label();
3676         }
3677
3678         // Administrative methods:
3679
3680         size_t codeSize() const { return m_buffer.codeSize(); }
3681         AssemblerLabel label() const { return m_buffer.label(); }
3682         bool isAligned(int alignment) const { return m_buffer.isAligned(alignment); }
3683         void* data() const { return m_buffer.data(); }
3684
3685         unsigned debugOffset() { return m_buffer.debugOffset(); }
3686
3687     public:
3688         AssemblerBuffer m_buffer;
3689     } m_formatter;
3690     int m_indexOfLastWatchpoint;
3691     int m_indexOfTailOfLastWatchpoint;
3692 };
3693
3694 } // namespace JSC
3695
3696 #endif // ENABLE(ASSEMBLER) && CPU(X86)
3697
3698 #endif // X86Assembler_h