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