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