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