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