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