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