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