1 /***************************************************************************
2 * Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
18 ***************************************************************************/
19
20 /*
21 * ix86 core v0.5.1
22 * Authors: linuzappz <linuzappz@pcsx.net>
23 * alexey silinov
24 */
25
26 #ifdef __i386__
27
28 #include "ix86.h"
29
30 s8 *x86Ptr;
31 u8 *j8Ptr[32];
32 u32 *j32Ptr[32];
33
x86Init()34 void x86Init() {
35 }
36
x86SetPtr(char * ptr)37 void x86SetPtr(char *ptr) {
38 x86Ptr = ptr;
39 }
40
x86Shutdown()41 void x86Shutdown() {
42 }
43
x86SetJ8(u8 * j8)44 void x86SetJ8(u8 *j8) {
45 u32 jump = (x86Ptr - (s8*)j8) - 1;
46
47 if (jump > 0x7f) printf("j8 greater than 0x7f!!\n");
48 *j8 = (u8)jump;
49 }
50
x86SetJ32(u32 * j32)51 void x86SetJ32(u32 *j32) {
52 *j32 = (x86Ptr - (s8*)j32) - 4;
53 }
54
x86Align(int bytes)55 void x86Align(int bytes) {
56 // fordward align
57 x86Ptr = (s8*)(((u32)x86Ptr + bytes) & ~(bytes - 1));
58 }
59
60 #define SIB 4
61 #define DISP32 5
62
63 /* macros helpers */
64
65 #define ModRM(mod, rm, reg) \
66 write8((mod << 6) | (rm << 3) | (reg));
67
68 #define SibSB(ss, rm, index) \
69 write8((ss << 6) | (rm << 3) | (index));
70
71 #define SET8R(cc, to) { \
72 write8(0x0F); write8(cc); \
73 write8((0xC0) | (to)); }
74
75 #define J8Rel(cc, to) { \
76 write8(cc); write8(to); return x86Ptr - 1; }
77
78 #define J32Rel(cc, to) { \
79 write8(0x0F); write8(cc); write32(to); return (u32*)(x86Ptr - 4); }
80
81 #define CMOV32RtoR(cc, to, from) { \
82 write8(0x0F); write8(cc); \
83 ModRM(3, to, from); }
84
85 #define CMOV32MtoR(cc, to, from) { \
86 write8(0x0F); write8(cc); \
87 ModRM(0, to, DISP32); \
88 write32(from); }
89
90 /********************/
91 /* IX86 intructions */
92 /********************/
93
94 // mov instructions
95
96 /* mov r32 to r32 */
MOV32RtoR(int to,int from)97 void MOV32RtoR(int to, int from) {
98 write8(0x89);
99 ModRM(3, from, to);
100 }
101
102 /* mov r32 to m32 */
MOV32RtoM(u32 to,int from)103 void MOV32RtoM(u32 to, int from) {
104 write8(0x89);
105 ModRM(0, from, DISP32);
106 write32(to);
107 }
108
109 /* mov m32 to r32 */
MOV32MtoR(int to,u32 from)110 void MOV32MtoR(int to, u32 from) {
111 write8(0x8B);
112 ModRM(0, to, DISP32);
113 write32(from);
114 }
115
116 /* mov [r32] to r32 */
MOV32RmtoR(int to,int from)117 void MOV32RmtoR(int to, int from) {
118 write8(0x8B);
119 ModRM(0, to, from);
120 }
121
122 /* mov [r32][r32*scale] to r32 */
MOV32RmStoR(int to,int from,int from2,int scale)123 void MOV32RmStoR(int to, int from, int from2, int scale) {
124 write8(0x8B);
125 ModRM(0, to, 0x4);
126 SibSB(scale, from2, from);
127 }
128
129 /* mov r32 to [r32] */
MOV32RtoRm(int to,int from)130 void MOV32RtoRm(int to, int from) {
131 write8(0x89);
132 ModRM(0, from, to);
133 }
134
135 /* mov r32 to [r32][r32*scale] */
MOV32RtoRmS(int to,int to2,int scale,int from)136 void MOV32RtoRmS(int to, int to2, int scale, int from) {
137 write8(0x89);
138 ModRM(0, from, 0x4);
139 SibSB(scale, to2, to);
140 }
141
142 /* mov imm32 to r32 */
MOV32ItoR(int to,u32 from)143 void MOV32ItoR(int to, u32 from) {
144 write8(0xB8 | to);
145 write32(from);
146 }
147
148 /* mov imm32 to m32 */
MOV32ItoM(u32 to,u32 from)149 void MOV32ItoM(u32 to, u32 from) {
150 write8(0xC7);
151 ModRM(0, 0, DISP32);
152 write32(to);
153 write32(from);
154 }
155
156 /* mov r16 to m16 */
MOV16RtoM(u32 to,int from)157 void MOV16RtoM(u32 to, int from) {
158 write8(0x66);
159 write8(0x89);
160 ModRM(0, from, DISP32);
161 write32(to);
162 }
163
164 /* mov m16 to r16 */
MOV16MtoR(int to,u32 from)165 void MOV16MtoR(int to, u32 from) {
166 write8(0x66);
167 write8(0x8B);
168 ModRM(0, to, DISP32);
169 write32(from);
170 }
171
172 /* mov imm16 to m16 */
MOV16ItoM(u32 to,u16 from)173 void MOV16ItoM(u32 to, u16 from) {
174 write8(0x66);
175 write8(0xC7);
176 ModRM(0, 0, DISP32);
177 write32(to);
178 write16(from);
179 }
180
181 /* mov r8 to m8 */
MOV8RtoM(u32 to,int from)182 void MOV8RtoM(u32 to, int from) {
183 write8(0x88);
184 ModRM(0, from, DISP32);
185 write32(to);
186 }
187
188 /* mov m8 to r8 */
MOV8MtoR(int to,u32 from)189 void MOV8MtoR(int to, u32 from) {
190 write8(0x8A);
191 ModRM(0, to, DISP32);
192 write32(from);
193 }
194
195 /* mov imm8 to m8 */
MOV8ItoM(u32 to,u8 from)196 void MOV8ItoM(u32 to, u8 from) {
197 write8(0xC6);
198 ModRM(0, 0, DISP32);
199 write32(to);
200 write8(from);
201 }
202
203 /* movsx r8 to r32 */
MOVSX32R8toR(int to,int from)204 void MOVSX32R8toR(int to, int from) {
205 write16(0xBE0F);
206 ModRM(3, to, from);
207 }
208
209 /* movsx m8 to r32 */
MOVSX32M8toR(int to,u32 from)210 void MOVSX32M8toR(int to, u32 from) {
211 write16(0xBE0F);
212 ModRM(0, to, DISP32);
213 write32(from);
214 }
215
216 /* movsx r16 to r32 */
MOVSX32R16toR(int to,int from)217 void MOVSX32R16toR(int to, int from) {
218 write16(0xBF0F);
219 ModRM(3, to, from);
220 }
221
222 /* movsx m16 to r32 */
MOVSX32M16toR(int to,u32 from)223 void MOVSX32M16toR(int to, u32 from) {
224 write16(0xBF0F);
225 ModRM(0, to, DISP32);
226 write32(from);
227 }
228
229 /* movzx r8 to r32 */
MOVZX32R8toR(int to,int from)230 void MOVZX32R8toR(int to, int from) {
231 write16(0xB60F);
232 ModRM(3, to, from);
233 }
234
235 /* movzx m8 to r32 */
MOVZX32M8toR(int to,u32 from)236 void MOVZX32M8toR(int to, u32 from) {
237 write16(0xB60F);
238 ModRM(0, to, DISP32);
239 write32(from);
240 }
241
242 /* movzx r16 to r32 */
MOVZX32R16toR(int to,int from)243 void MOVZX32R16toR(int to, int from) {
244 write16(0xB70F);
245 ModRM(3, to, from);
246 }
247
248 /* movzx m16 to r32 */
MOVZX32M16toR(int to,u32 from)249 void MOVZX32M16toR(int to, u32 from) {
250 write16(0xB70F);
251 ModRM(0, to, DISP32);
252 write32(from);
253 }
254
255 /* cmovne r32 to r32 */
CMOVNE32RtoR(int to,int from)256 void CMOVNE32RtoR(int to, int from) {
257 CMOV32RtoR(0x45, to, from);
258 }
259
260 /* cmovne m32 to r32*/
CMOVNE32MtoR(int to,u32 from)261 void CMOVNE32MtoR(int to, u32 from) {
262 CMOV32MtoR(0x45, to, from);
263 }
264
265 /* cmove r32 to r32*/
CMOVE32RtoR(int to,int from)266 void CMOVE32RtoR(int to, int from) {
267 CMOV32RtoR(0x44, to, from);
268 }
269
270 /* cmove m32 to r32*/
CMOVE32MtoR(int to,u32 from)271 void CMOVE32MtoR(int to, u32 from) {
272 CMOV32MtoR(0x44, to, from);
273 }
274
275 /* cmovg r32 to r32*/
CMOVG32RtoR(int to,int from)276 void CMOVG32RtoR(int to, int from) {
277 CMOV32RtoR(0x4F, to, from);
278 }
279
280 /* cmovg m32 to r32*/
CMOVG32MtoR(int to,u32 from)281 void CMOVG32MtoR(int to, u32 from) {
282 CMOV32MtoR(0x4F, to, from);
283 }
284
285 /* cmovge r32 to r32*/
CMOVGE32RtoR(int to,int from)286 void CMOVGE32RtoR(int to, int from) {
287 CMOV32RtoR(0x4D, to, from);
288 }
289
290 /* cmovge m32 to r32*/
CMOVGE32MtoR(int to,u32 from)291 void CMOVGE32MtoR(int to, u32 from) {
292 CMOV32MtoR(0x4D, to, from);
293 }
294
295 /* cmovl r32 to r32*/
CMOVL32RtoR(int to,int from)296 void CMOVL32RtoR(int to, int from) {
297 CMOV32RtoR(0x4C, to, from);
298 }
299
300 /* cmovl m32 to r32*/
CMOVL32MtoR(int to,u32 from)301 void CMOVL32MtoR(int to, u32 from) {
302 CMOV32MtoR(0x4C, to, from);
303 }
304
305 /* cmovle r32 to r32*/
CMOVLE32RtoR(int to,int from)306 void CMOVLE32RtoR(int to, int from) {
307 CMOV32RtoR(0x4E, to, from);
308 }
309
310 /* cmovle m32 to r32*/
CMOVLE32MtoR(int to,u32 from)311 void CMOVLE32MtoR(int to, u32 from) {
312 CMOV32MtoR(0x4E, to, from);
313 }
314
315 // arithmic instructions
316
317 /* add imm32 to r32 */
ADD32ItoR(int to,u32 from)318 void ADD32ItoR(int to, u32 from) {
319 if (to == EAX) {
320 write8(0x05);
321 } else {
322 write8(0x81);
323 ModRM(3, 0, to);
324 }
325 write32(from);
326 }
327
328 /* add imm32 to m32 */
ADD32ItoM(u32 to,u32 from)329 void ADD32ItoM(u32 to, u32 from) {
330 write8(0x81);
331 ModRM(0, 0, DISP32);
332 write32(to);
333 write32(from);
334 }
335
336 /* add r32 to r32 */
ADD32RtoR(int to,int from)337 void ADD32RtoR(int to, int from) {
338 write8(0x01);
339 ModRM(3, from, to);
340 }
341
342 /* add r32 to m32 */
ADD32RtoM(u32 to,int from)343 void ADD32RtoM(u32 to, int from) {
344 write8(0x01);
345 ModRM(0, from, DISP32);
346 write32(to);
347 }
348
349 /* add m32 to r32 */
ADD32MtoR(int to,u32 from)350 void ADD32MtoR(int to, u32 from) {
351 write8(0x03);
352 ModRM(0, to, DISP32);
353 write32(from);
354 }
355
356 /* adc imm32 to r32 */
ADC32ItoR(int to,u32 from)357 void ADC32ItoR(int to, u32 from) {
358 if (to == EAX) {
359 write8(0x15);
360 } else {
361 write8(0x81);
362 ModRM(3, 2, to);
363 }
364 write32(from);
365 }
366
367 /* adc r32 to r32 */
ADC32RtoR(int to,int from)368 void ADC32RtoR(int to, int from) {
369 write8(0x11);
370 ModRM(3, from, to);
371 }
372
373 /* adc m32 to r32 */
ADC32MtoR(int to,u32 from)374 void ADC32MtoR(int to, u32 from) {
375 write8(0x13);
376 ModRM(0, to, DISP32);
377 write32(from);
378 }
379
380 /* inc r32 */
INC32R(int to)381 void INC32R(int to) {
382 write8(0x40 + to);
383 }
384
385 /* inc m32 */
INC32M(u32 to)386 void INC32M(u32 to) {
387 write8(0xFF);
388 ModRM(0, 0, DISP32);
389 write32(to);
390 }
391
392 /* sub imm32 to r32 */
SUB32ItoR(int to,u32 from)393 void SUB32ItoR(int to, u32 from) {
394 if (to == EAX) {
395 write8(0x2D);
396 } else {
397 write8(0x81);
398 ModRM(3, 5, to);
399 }
400 write32(from);
401 }
402
403 /* sub r32 to r32 */
SUB32RtoR(int to,int from)404 void SUB32RtoR(int to, int from) {
405 write8(0x29);
406 ModRM(3, from, to);
407 }
408
409 /* sub m32 to r32 */
SUB32MtoR(int to,u32 from)410 void SUB32MtoR(int to, u32 from) {
411 write8(0x2B);
412 ModRM(0, to, DISP32);
413 write32(from);
414 }
415
416 /* sbb imm32 to r32 */
SBB32ItoR(int to,u32 from)417 void SBB32ItoR(int to, u32 from) {
418 if (to == EAX) {
419 write8(0x1D);
420 } else {
421 write8(0x81);
422 ModRM(3, 3, to);
423 }
424 write32(from);
425 }
426
427 /* sbb r32 to r32 */
SBB32RtoR(int to,int from)428 void SBB32RtoR(int to, int from) {
429 write8(0x19);
430 ModRM(3, from, to);
431 }
432
433 /* sbb m32 to r32 */
SBB32MtoR(int to,u32 from)434 void SBB32MtoR(int to, u32 from) {
435 write8(0x1B);
436 ModRM(0, to, DISP32);
437 write32(from);
438 }
439
440 /* dec r32 */
DEC32R(int to)441 void DEC32R(int to) {
442 write8(0x48 + to);
443 }
444
445 /* dec m32 */
DEC32M(u32 to)446 void DEC32M(u32 to) {
447 write8(0xFF);
448 ModRM(0, 1, DISP32);
449 write32(to);
450 }
451
452 /* mul eax by r32 to edx:eax */
MUL32R(int from)453 void MUL32R(int from) {
454 write8(0xF7);
455 ModRM(3, 4, from);
456 }
457
458 /* imul eax by r32 to edx:eax */
IMUL32R(int from)459 void IMUL32R(int from) {
460 write8(0xF7);
461 ModRM(3, 5, from);
462 }
463
464 /* mul eax by m32 to edx:eax */
MUL32M(u32 from)465 void MUL32M(u32 from) {
466 write8(0xF7);
467 ModRM(0, 4, DISP32);
468 write32(from);
469 }
470
471 /* imul eax by m32 to edx:eax */
IMUL32M(u32 from)472 void IMUL32M(u32 from) {
473 write8(0xF7);
474 ModRM(0, 5, DISP32);
475 write32(from);
476 }
477
478 /* imul r32 by r32 to r32 */
IMUL32RtoR(int to,int from)479 void IMUL32RtoR(int to, int from) {
480 write16(0xAF0F);
481 ModRM(3, to, from);
482 }
483
484 /* div eax by r32 to edx:eax */
DIV32R(int from)485 void DIV32R(int from) {
486 write8(0xF7);
487 ModRM(3, 6, from);
488 }
489
490 /* idiv eax by r32 to edx:eax */
IDIV32R(int from)491 void IDIV32R(int from) {
492 write8(0xF7);
493 ModRM(3, 7, from);
494 }
495
496 /* div eax by m32 to edx:eax */
DIV32M(u32 from)497 void DIV32M(u32 from) {
498 write8(0xF7);
499 ModRM(0, 6, DISP32);
500 write32(from);
501 }
502
503 /* idiv eax by m32 to edx:eax */
IDIV32M(u32 from)504 void IDIV32M(u32 from) {
505 write8(0xF7);
506 ModRM(0, 7, DISP32);
507 write32(from);
508 }
509
510 // shifting instructions
511
RCR32ItoR(int to,int from)512 void RCR32ItoR(int to,int from)
513 {
514 if (from==1)
515 {
516 write8(0xd1);
517 write8(0xd8 | to);
518 }
519 else
520 {
521 write8(0xc1);
522 write8(0xd8 | to);
523 write8(from);
524 }
525 }
526
527 /* shl imm8 to r32 */
SHL32ItoR(int to,u8 from)528 void SHL32ItoR(int to, u8 from) {
529 if (from==1)
530 {
531 write8(0xd1);
532 write8(0xe0 | to);
533 return;
534 }
535 write8(0xC1);
536 ModRM(3, 4, to);
537 write8(from);
538 }
539
540 /* shl cl to r32 */
SHL32CLtoR(int to)541 void SHL32CLtoR(int to) {
542 write8(0xD3);
543 ModRM(3, 4, to);
544 }
545
546 /* shr imm8 to r32 */
SHR32ItoR(int to,u8 from)547 void SHR32ItoR(int to, u8 from) {
548 if (from==1)
549 {
550 write8(0xd1);
551 write8(0xe8 | to);
552 return;
553 }
554 write8(0xC1);
555 ModRM(3, 5, to);
556 write8(from);
557 }
558
559 /* shr cl to r32 */
SHR32CLtoR(int to)560 void SHR32CLtoR(int to) {
561 write8(0xD3);
562 ModRM(3, 5, to);
563 }
564
565 /* sar imm8 to r32 */
SAR32ItoR(int to,u8 from)566 void SAR32ItoR(int to, u8 from) {
567 write8(0xC1);
568 ModRM(3, 7, to);
569 write8(from);
570 }
571
572 /* sar cl to r32 */
SAR32CLtoR(int to)573 void SAR32CLtoR(int to) {
574 write8(0xD3);
575 ModRM(3, 7, to);
576 }
577
578
579 // logical instructions
580
581 /* or imm32 to r32 */
OR32ItoR(int to,u32 from)582 void OR32ItoR(int to, u32 from) {
583 if (to == EAX) {
584 write8(0x0D);
585 } else {
586 write8(0x81);
587 ModRM(3, 1, to);
588 }
589 write32(from);
590 }
591
592 /* or imm32 to m32 */
OR32ItoM(u32 to,u32 from)593 void OR32ItoM(u32 to, u32 from) {
594 write8(0x81);
595 ModRM(0, 1, DISP32);
596 write32(to);
597 write32(from);
598 }
599
600 /* or r32 to r32 */
OR32RtoR(int to,int from)601 void OR32RtoR(int to, int from) {
602 write8(0x09);
603 ModRM(3, from, to);
604 }
605
606 /* or r32 to m32 */
OR32RtoM(u32 to,int from)607 void OR32RtoM(u32 to, int from) {
608 write8(0x09);
609 ModRM(0, from, DISP32);
610 write32(to);
611 }
612
613 /* or m32 to r32 */
OR32MtoR(int to,u32 from)614 void OR32MtoR(int to, u32 from) {
615 write8(0x0B);
616 ModRM(0, to, DISP32);
617 write32(from);
618 }
619
620 /* xor imm32 to r32 */
XOR32ItoR(int to,u32 from)621 void XOR32ItoR(int to, u32 from) {
622 if (to == EAX) {
623 write8(0x35);
624 } else {
625 write8(0x81);
626 ModRM(3, 6, to);
627 }
628 write32(from);
629 }
630
631 /* xor imm32 to m32 */
XOR32ItoM(u32 to,u32 from)632 void XOR32ItoM(u32 to, u32 from) {
633 write8(0x81);
634 ModRM(0, 6, DISP32);
635 write32(to);
636 write32(from);
637 }
638
639 /* xor r32 to r32 */
XOR32RtoR(int to,int from)640 void XOR32RtoR(int to, int from) {
641 write8(0x31);
642 ModRM(3, from, to);
643 }
644
645 /* xor r32 to m32 */
XOR32RtoM(u32 to,int from)646 void XOR32RtoM(u32 to, int from) {
647 write8(0x31);
648 ModRM(0, from, DISP32);
649 write32(to);
650 }
651
652 /* xor m32 to r32 */
XOR32MtoR(int to,u32 from)653 void XOR32MtoR(int to, u32 from) {
654 write8(0x33);
655 ModRM(0, to, DISP32);
656 write32(from);
657 }
658
659 /* and imm32 to r32 */
AND32ItoR(int to,u32 from)660 void AND32ItoR(int to, u32 from) {
661 if (to == EAX) {
662 write8(0x25);
663 } else {
664 write8(0x81);
665 ModRM(3, 0x4, to);
666 }
667 write32(from);
668 }
669
670 /* and imm32 to m32 */
AND32ItoM(u32 to,u32 from)671 void AND32ItoM(u32 to, u32 from) {
672 write8(0x81);
673 ModRM(0, 0x4, DISP32);
674 write32(to);
675 write32(from);
676 }
677
678 /* and r32 to r32 */
AND32RtoR(int to,int from)679 void AND32RtoR(int to, int from) {
680 write8(0x21);
681 ModRM(3, from, to);
682 }
683
684 /* and r32 to m32 */
AND32RtoM(u32 to,int from)685 void AND32RtoM(u32 to, int from) {
686 write8(0x21);
687 ModRM(0, from, DISP32);
688 write32(to);
689 }
690
691 /* and m32 to r32 */
AND32MtoR(int to,u32 from)692 void AND32MtoR(int to, u32 from) {
693 write8(0x23);
694 ModRM(0, to, DISP32);
695 write32(from);
696 }
697
698 /* not r32 */
NOT32R(int from)699 void NOT32R(int from) {
700 write8(0xF7);
701 ModRM(3, 2, from);
702 }
703
704 /* neg r32 */
NEG32R(int from)705 void NEG32R(int from) {
706 write8(0xF7);
707 ModRM(3, 3, from);
708 }
709
710 // jump instructions
711
712 /* jmp rel8 */
JMP8(u8 to)713 u8* JMP8(u8 to) {
714 write8(0xEB);
715 write8(to);
716 return x86Ptr - 1;
717 }
718
719 /* jmp rel32 */
JMP32(u32 to)720 u32* JMP32(u32 to) {
721 write8(0xE9);
722 write32(to);
723 return (u32*)(x86Ptr - 4);
724 }
725
726 /* jmp r32 */
JMP32R(int to)727 void JMP32R(int to) {
728 write8(0xFF);
729 ModRM(3, 4, to);
730 }
731
732 /* je rel8 */
JE8(u8 to)733 u8* JE8(u8 to) {
734 J8Rel(0x74, to);
735 }
736
737 /* jz rel8 */
JZ8(u8 to)738 u8* JZ8(u8 to) {
739 J8Rel(0x74, to);
740 }
741
742 /* jg rel8 */
JG8(u8 to)743 u8* JG8(u8 to) {
744 J8Rel(0x7F, to);
745 }
746
747 /* jge rel8 */
JGE8(u8 to)748 u8* JGE8(u8 to) {
749 J8Rel(0x7D, to);
750 }
751
752 /* jl rel8 */
JL8(u8 to)753 u8* JL8(u8 to) {
754 J8Rel(0x7C, to);
755 }
756
757 /* jle rel8 */
JLE8(u8 to)758 u8* JLE8(u8 to) {
759 J8Rel(0x7E, to);
760 }
761
762 /* jne rel8 */
JNE8(u8 to)763 u8* JNE8(u8 to) {
764 J8Rel(0x75, to);
765 }
766
767 /* jnz rel8 */
JNZ8(u8 to)768 u8* JNZ8(u8 to) {
769 J8Rel(0x75, to);
770 }
771
772 /* jng rel8 */
JNG8(u8 to)773 u8* JNG8(u8 to) {
774 J8Rel(0x7E, to);
775 }
776
777 /* jnge rel8 */
JNGE8(u8 to)778 u8* JNGE8(u8 to) {
779 J8Rel(0x7C, to);
780 }
781
782 /* jnl rel8 */
JNL8(u8 to)783 u8* JNL8(u8 to) {
784 J8Rel(0x7D, to);
785 }
786
787 /* jnle rel8 */
JNLE8(u8 to)788 u8* JNLE8(u8 to) {
789 J8Rel(0x7F, to);
790 }
791
792 /* jo rel8 */
JO8(u8 to)793 u8* JO8(u8 to) {
794 J8Rel(0x70, to);
795 }
796
797 /* jno rel8 */
JNO8(u8 to)798 u8* JNO8(u8 to) {
799 J8Rel(0x71, to);
800 }
801
802 /* je rel32 */
JE32(u32 to)803 u32* JE32(u32 to) {
804 J32Rel(0x84, to);
805 }
806
807 /* jz rel32 */
JZ32(u32 to)808 u32* JZ32(u32 to) {
809 J32Rel(0x84, to);
810 }
811
812 /* jg rel32 */
JG32(u32 to)813 u32* JG32(u32 to) {
814 J32Rel(0x8F, to);
815 }
816
817 /* jge rel32 */
JGE32(u32 to)818 u32* JGE32(u32 to) {
819 J32Rel(0x8D, to);
820 }
821
822 /* jl rel32 */
JL32(u32 to)823 u32* JL32(u32 to) {
824 J32Rel(0x8C, to);
825 }
826
827 /* jle rel32 */
JLE32(u32 to)828 u32* JLE32(u32 to) {
829 J32Rel(0x8E, to);
830 }
831
832 /* jne rel32 */
JNE32(u32 to)833 u32* JNE32(u32 to) {
834 J32Rel(0x85, to);
835 }
836
837 /* jnz rel32 */
JNZ32(u32 to)838 u32* JNZ32(u32 to) {
839 J32Rel(0x85, to);
840 }
841
842 /* jng rel32 */
JNG32(u32 to)843 u32* JNG32(u32 to) {
844 J32Rel(0x8E, to);
845 }
846
847 /* jnge rel32 */
JNGE32(u32 to)848 u32* JNGE32(u32 to) {
849 J32Rel(0x8C, to);
850 }
851
852 /* jnl rel32 */
JNL32(u32 to)853 u32* JNL32(u32 to) {
854 J32Rel(0x8D, to);
855 }
856
857 /* jnle rel32 */
JNLE32(u32 to)858 u32* JNLE32(u32 to) {
859 J32Rel(0x8F, to);
860 }
861
862 /* jo rel32 */
JO32(u32 to)863 u32* JO32(u32 to) {
864 J32Rel(0x80, to);
865 }
866
867 /* jno rel32 */
JNO32(u32 to)868 u32* JNO32(u32 to) {
869 J32Rel(0x81, to);
870 }
871
872 /* call func */
CALLFunc(u32 func)873 void CALLFunc(u32 func) {
874 CALL32(func - ((u32)x86Ptr + 5));
875 }
876
877 /* call rel32 */
CALL32(u32 to)878 void CALL32(u32 to) {
879 write8(0xE8);
880 write32(to);
881 }
882
883 /* call r32 */
CALL32R(int to)884 void CALL32R(int to) {
885 write8(0xFF);
886 ModRM(3, 2, to);
887 }
888
889 /* call m32 */
CALL32M(u32 to)890 void CALL32M(u32 to) {
891 write8(0xFF);
892 ModRM(0, 2, DISP32);
893 write32(to);
894 }
895
896 // misc instructions
897
898 /* cmp imm32 to r32 */
CMP32ItoR(int to,u32 from)899 void CMP32ItoR(int to, u32 from) {
900 if (to == EAX) {
901 write8(0x3D);
902 } else {
903 write8(0x81);
904 ModRM(3, 7, to);
905 }
906 write32(from);
907 }
908
909 /* cmp imm32 to m32 */
CMP32ItoM(u32 to,u32 from)910 void CMP32ItoM(u32 to, u32 from) {
911 write8(0x81);
912 ModRM(0, 7, DISP32);
913 write32(to);
914 write32(from);
915 }
916
917 /* cmp r32 to r32 */
CMP32RtoR(int to,int from)918 void CMP32RtoR(int to, int from) {
919 write8(0x39);
920 ModRM(3, from, to);
921 }
922
923 /* cmp m32 to r32 */
CMP32MtoR(int to,u32 from)924 void CMP32MtoR(int to, u32 from) {
925 write8(0x3B);
926 ModRM(0, to, DISP32);
927 write32(from);
928 }
929
930 /* test imm32 to r32 */
TEST32ItoR(int to,u32 from)931 void TEST32ItoR(int to, u32 from) {
932 if (to == EAX) {
933 write8(0xA9);
934 } else {
935 write8(0xF7);
936 ModRM(3, 0, to);
937 }
938 write32(from);
939 }
940
941 /* test r32 to r32 */
TEST32RtoR(int to,int from)942 void TEST32RtoR(int to, int from) {
943 write8(0x85);
944 ModRM(3, from, to);
945 }
946
BT32ItoR(int to,int from)947 void BT32ItoR(int to,int from)
948 {
949 write16(0xba0f);
950 write8(0xe0 | to);
951 write8(from);
952 }
953
954 /* sets r8 */
SETS8R(int to)955 void SETS8R(int to) {
956 SET8R(0x98, to);
957 }
958 /* setl r8 */
SETL8R(int to)959 void SETL8R(int to) {
960 SET8R(0x9C, to);
961 }
962
963 /* setb r8 */
SETB8R(int to)964 void SETB8R(int to) {
965 SET8R(0x92, to);
966 }
967
968 /* setnz r8 */
SETNZ8R(int to)969 void SETNZ8R(int to) {
970 SET8R(0x95,to);
971 }
972
973 /* cbw */
CBW()974 void CBW() {
975 write16(0x9866);
976 }
977
978 /* cwd */
CWD()979 void CWD() {
980 write8(0x98);
981 }
982
983 /* cdq */
CDQ()984 void CDQ() {
985 write8(0x99);
986 }
987
988 /* push r32 */
PUSH32R(int from)989 void PUSH32R(int from) {
990 write8(0x50 | from);
991 }
992
993 /* push m32 */
PUSH32M(u32 from)994 void PUSH32M(u32 from) {
995 write8(0xFF);
996 ModRM(0, 6, DISP32);
997 write32(from);
998 }
999
1000 /* push imm32 */
PUSH32I(u32 from)1001 void PUSH32I(u32 from) {
1002 write8(0x68); write32(from);
1003 }
1004
1005 /* pop r32 */
POP32R(int from)1006 void POP32R(int from) {
1007 write8(0x58 | from);
1008 }
1009
1010 /* pushad */
PUSHA32()1011 void PUSHA32() {
1012 write8(0x60);
1013 }
1014
1015 /* popad */
POPA32()1016 void POPA32() {
1017 write8(0x61);
1018 }
1019
1020 /* ret */
RET()1021 void RET() {
1022 write8(0xC3);
1023 }
1024
1025 /********************/
1026 /* FPU instructions */
1027 /********************/
1028
1029 //Added:basara 14.01.2003
1030 /* compare m32 to fpu reg stack */
FCOMP32(u32 from)1031 void FCOMP32(u32 from) {
1032 write8(0xD8);
1033 ModRM(0, 0x3, DISP32);
1034 write32(from);
1035 }
1036
FNSTSWtoAX()1037 void FNSTSWtoAX() {
1038 write16(0xE0DF);
1039 }
1040
1041 /* fild m32 to fpu reg stack */
FILD32(u32 from)1042 void FILD32(u32 from) {
1043 write8(0xDB);
1044 ModRM(0, 0x0, DISP32);
1045 write32(from);
1046 }
1047
1048 /* fistp m32 from fpu reg stack */
FISTP32(u32 from)1049 void FISTP32(u32 from) {
1050 write8(0xDB);
1051 ModRM(0, 0x3, DISP32);
1052 write32(from);
1053 }
1054
1055 /* fld m32 to fpu reg stack */
FLD32(u32 from)1056 void FLD32(u32 from) {
1057 write8(0xD9);
1058 ModRM(0, 0x0, DISP32);
1059 write32(from);
1060 }
1061
1062 /* fstp m32 from fpu reg stack */
FSTP32(u32 to)1063 void FSTP32(u32 to) {
1064 write8(0xD9);
1065 ModRM(0, 0x3, DISP32);
1066 write32(to);
1067 }
1068
1069 //
1070
1071 /* fldcw fpu control word from m16 */
FLDCW(u32 from)1072 void FLDCW(u32 from) {
1073 write8(0xD9);
1074 ModRM(0, 0x5, DISP32);
1075 write32(from);
1076 }
1077
1078 /* fnstcw fpu control word to m16 */
FNSTCW(u32 to)1079 void FNSTCW(u32 to) {
1080 write8(0xD9);
1081 ModRM(0, 0x7, DISP32);
1082 write32(to);
1083 }
1084
1085 //
1086
1087 /* fadd m32 to fpu reg stack */
FADD32(u32 from)1088 void FADD32(u32 from) {
1089 write8(0xD8);
1090 ModRM(0, 0x0, DISP32);
1091 write32(from);
1092 }
1093
1094 /* fsub m32 to fpu reg stack */
FSUB32(u32 from)1095 void FSUB32(u32 from) {
1096 write8(0xD8);
1097 ModRM(0, 0x4, DISP32);
1098 write32(from);
1099 }
1100
1101 /* fmul m32 to fpu reg stack */
FMUL32(u32 from)1102 void FMUL32(u32 from) {
1103 write8(0xD8);
1104 ModRM(0, 0x1, DISP32);
1105 write32(from);
1106 }
1107
1108 /* fdiv m32 to fpu reg stack */
FDIV32(u32 from)1109 void FDIV32(u32 from) {
1110 write8(0xD8);
1111 ModRM(0, 0x6, DISP32);
1112 write32(from);
1113 }
1114
1115 /* fabs fpu reg stack */
FABS()1116 void FABS() {
1117 write16(0xE1D9);
1118 }
1119
1120 /* fsqrt fpu reg stack */
FSQRT()1121 void FSQRT() {
1122 write16(0xFAD9);
1123 }
1124
1125 /* fchs fpu reg stack */
FCHS()1126 void FCHS() {
1127 write16(0xE0D9);
1128 }
1129
1130 /********************/
1131 /* MMX instructions */
1132 /********************/
1133
1134 // r64 = mm
1135
1136 /* movq m64 to r64 */
MOVQMtoR(int to,u32 from)1137 void MOVQMtoR(int to, u32 from) {
1138 write16(0x6F0F);
1139 ModRM(0, to, DISP32);
1140 write32(from);
1141 }
1142
1143 /* movq r64 to m64 */
MOVQRtoM(u32 to,int from)1144 void MOVQRtoM(u32 to, int from) {
1145 write16(0x7F0F);
1146 ModRM(0, from, DISP32);
1147 write32(to);
1148 }
1149
1150 /* pand r64 to r64 */
PANDRtoR(int to,int from)1151 void PANDRtoR(int to, int from) {
1152 write16(0xDB0F);
1153 ModRM(3, to, from);
1154 }
1155
1156 /* pand r64 to r64 */
PANDNRtoR(int to,int from)1157 void PANDNRtoR(int to, int from) {
1158 write16(0xDF0F);
1159 ModRM(3, to, from);
1160 }
1161
1162 /* por r64 to r64 */
PORRtoR(int to,int from)1163 void PORRtoR(int to, int from) {
1164 write16(0xEB0F);
1165 ModRM(3, to, from);
1166 }
1167
1168 /* pxor r64 to r64 */
PXORRtoR(int to,int from)1169 void PXORRtoR(int to, int from) {
1170 write16(0xEF0F);
1171 ModRM(3, to, from);
1172 }
1173
1174 /* psllq r64 to r64 */
PSLLQRtoR(int to,int from)1175 void PSLLQRtoR(int to, int from) {
1176 write16(0xF30F);
1177 ModRM(3, to, from);
1178 }
1179
1180 /* psllq m64 to r64 */
PSLLQMtoR(int to,u32 from)1181 void PSLLQMtoR(int to, u32 from) {
1182 write16(0xF30F);
1183 ModRM(0, to, DISP32);
1184 write32(from);
1185 }
1186
1187 /* psllq imm8 to r64 */
PSLLQItoR(int to,u8 from)1188 void PSLLQItoR(int to, u8 from) {
1189 write16(0x730F);
1190 ModRM(3, 6, to);
1191 write8(from);
1192 }
1193
1194 /* psrlq r64 to r64 */
PSRLQRtoR(int to,int from)1195 void PSRLQRtoR(int to, int from) {
1196 write16(0xD30F);
1197 ModRM(3, to, from);
1198 }
1199
1200 /* psrlq m64 to r64 */
PSRLQMtoR(int to,u32 from)1201 void PSRLQMtoR(int to, u32 from) {
1202 write16(0xD30F);
1203 ModRM(0, to, DISP32);
1204 write32(from);
1205 }
1206
1207 /* psrlq imm8 to r64 */
PSRLQItoR(int to,u8 from)1208 void PSRLQItoR(int to, u8 from) {
1209 write16(0x730F);
1210 ModRM(3, 2, to);
1211 write8(from);
1212 }
1213
1214 /* paddusb r64 to r64 */
PADDUSBRtoR(int to,int from)1215 void PADDUSBRtoR(int to, int from) {
1216 write16(0xDC0F);
1217 ModRM(3, to, from);
1218 }
1219
1220 /* paddusb m64 to r64 */
PADDUSBMtoR(int to,u32 from)1221 void PADDUSBMtoR(int to, u32 from) {
1222 write16(0xDC0F);
1223 ModRM(0, to, DISP32);
1224 write32(from);
1225 }
1226
1227 /* paddusw r64 to r64 */
PADDUSWRtoR(int to,int from)1228 void PADDUSWRtoR(int to, int from) {
1229 write16(0xDD0F);
1230 ModRM(3, to, from);
1231 }
1232
1233 /* paddusw m64 to r64 */
PADDUSWMtoR(int to,u32 from)1234 void PADDUSWMtoR(int to, u32 from) {
1235 write16(0xDD0F);
1236 ModRM(0, to, DISP32);
1237 write32(from);
1238 }
1239
1240 /* paddb r64 to r64 */
PADDBRtoR(int to,int from)1241 void PADDBRtoR(int to, int from) {
1242 write16(0xFC0F);
1243 ModRM(3, to, from);
1244 }
1245
1246 /* paddb m64 to r64 */
PADDBMtoR(int to,u32 from)1247 void PADDBMtoR(int to, u32 from) {
1248 write16(0xFC0F);
1249 ModRM(0, to, DISP32);
1250 write32(from);
1251 }
1252
1253 /* paddw r64 to r64 */
PADDWRtoR(int to,int from)1254 void PADDWRtoR(int to, int from) {
1255 write16(0xFD0F);
1256 ModRM(3, to, from);
1257 }
1258
1259 /* paddw m64 to r64 */
PADDWMtoR(int to,u32 from)1260 void PADDWMtoR(int to, u32 from) {
1261 write16(0xFD0F);
1262 ModRM(0, to, DISP32);
1263 write32(from);
1264 }
1265
1266 /* paddd r64 to r64 */
PADDDRtoR(int to,int from)1267 void PADDDRtoR(int to, int from) {
1268 write16(0xFE0F);
1269 ModRM(3, to, from);
1270 }
1271
1272 /* paddd m64 to r64 */
PADDDMtoR(int to,u32 from)1273 void PADDDMtoR(int to, u32 from) {
1274 write16(0xFE0F);
1275 ModRM(0, to, DISP32);
1276 write32(from);
1277 }
1278
1279 /* emms */
EMMS()1280 void EMMS() {
1281 //use femms if we have 3dnow
1282 write16(0x0e0f);
1283 return;
1284 }
1285
1286 /* femms */
FEMMS()1287 void FEMMS() {
1288 write16(0x770F);
1289 return;
1290 }
1291
1292 //Basara:changed
PADDSBRtoR(int to,int from)1293 void PADDSBRtoR(int to, int from) {
1294 write16(0xEC0F);
1295 ModRM(3, to, from);
1296 }
1297
PADDSWRtoR(int to,int from)1298 void PADDSWRtoR(int to, int from) {
1299 write16(0xED0F);
1300 ModRM(3, to, from);
1301 }
1302
PADDSDRtoR(int to,int from)1303 void PADDSDRtoR(int to, int from) {
1304 write16(0xEE0F);
1305 ModRM(3, to, from);
1306 }
1307
PSUBSBRtoR(int to,int from)1308 void PSUBSBRtoR(int to, int from) {
1309 write16(0xE80F);
1310 ModRM(3, to, from);
1311 }
1312
PSUBSWRtoR(int to,int from)1313 void PSUBSWRtoR(int to, int from) {
1314 write16(0xE90F);
1315 ModRM(3, to, from);
1316 }
1317
PSUBSDRtoR(int to,int from)1318 void PSUBSDRtoR(int to, int from) {
1319 write16(0xEA0F);
1320 ModRM(3, to, from);
1321 }
1322
PSUBBRtoR(int to,int from)1323 void PSUBBRtoR(int to, int from) {
1324 write16(0xF80F);
1325 ModRM(3, to, from);
1326 }
1327
PSUBWRtoR(int to,int from)1328 void PSUBWRtoR(int to, int from) {
1329 write16(0xF90F);
1330 ModRM(3, to, from);
1331 }
1332
PSUBDRtoR(int to,int from)1333 void PSUBDRtoR(int to, int from) {
1334 write16(0xFA0F);
1335 ModRM(3, to, from);
1336 }
1337
1338 //changed:basara
1339 //P.s.It's sux.Don't use it offten.
MOVQ64ItoR(int reg,u64 i)1340 void MOVQ64ItoR(int reg,u64 i)
1341 {
1342 MOVQMtoR(reg,(u32)(x86Ptr)+2+7);
1343 JMP8(8);
1344 write64(i);
1345 }
1346
PSUBUSBRtoR(int to,int from)1347 void PSUBUSBRtoR(int to, int from) {
1348 write16(0xD80F);
1349 ModRM(3, to, from);
1350 }
1351
PSUBUSWRtoR(int to,int from)1352 void PSUBUSWRtoR(int to, int from) {
1353 write16(0xD90F);
1354 ModRM(3, to, from);
1355 }
1356
PMAXSWRtoR(int to,int from)1357 void PMAXSWRtoR(int to,int from)
1358 {
1359 write16(0xEE0F);
1360 ModRM(3, to, from);
1361 }
1362
PMINSWRtoR(int to,int from)1363 void PMINSWRtoR(int to,int from)
1364 {
1365 write16(0xEA0F);
1366 ModRM(3, to, from);
1367 }
1368
PCMPEQBRtoR(int to,int from)1369 void PCMPEQBRtoR(int to,int from)
1370 {
1371 write16(0x740F);
1372 ModRM(3, to, from);
1373 }
1374
PCMPEQWRtoR(int to,int from)1375 void PCMPEQWRtoR(int to,int from)
1376 {
1377 write16(0x750F);
1378 ModRM(3, to, from);
1379 }
1380
PCMPEQDRtoR(int to,int from)1381 void PCMPEQDRtoR(int to,int from)
1382 {
1383 write16(0x760F);
1384 ModRM(3, to, from);
1385 }
1386
PCMPGTBRtoR(int to,int from)1387 void PCMPGTBRtoR(int to,int from)
1388 {
1389 write16(0x640F);
1390 ModRM(3, to, from);
1391 }
1392
PCMPGTWRtoR(int to,int from)1393 void PCMPGTWRtoR(int to,int from)
1394 {
1395 write16(0x650F);
1396 ModRM(3, to, from);
1397 }
1398
PCMPGTDRtoR(int to,int from)1399 void PCMPGTDRtoR(int to,int from)
1400 {
1401 write16(0x660F);
1402 ModRM(3, to, from);
1403 }
1404
1405 //Basara:Added 10.01.2003
PSRLWItoR(int to,int from)1406 void PSRLWItoR(int to,int from)
1407 {
1408 write16(0x710f);
1409 ModRM(2, 2 , to);
1410 write8(from);
1411 }
PSRLDItoR(int to,int from)1412 void PSRLDItoR(int to,int from)
1413 {
1414 write16(0x720f);
1415 ModRM(2, 2 , to);
1416 write8(from);
1417 }
1418
PSLLWItoR(int to,int from)1419 void PSLLWItoR(int to,int from)
1420 {
1421 write16(0x710f);
1422 ModRM(3, 6 , to);
1423 write8(from);
1424 }
1425
PSLLDItoR(int to,int from)1426 void PSLLDItoR(int to,int from)
1427 {
1428 write16(0x720f);
1429 ModRM(3, 6 , to);
1430 write8(from);
1431 }
1432
PSRAWItoR(int to,int from)1433 void PSRAWItoR(int to,int from)
1434 {
1435 write16(0x710f);
1436 ModRM(3, 4 , to);
1437 write8(from);
1438 }
1439
PSRADItoR(int to,int from)1440 void PSRADItoR(int to,int from)
1441 {
1442 write16(0x720f);
1443 ModRM(3, 4 , to);
1444 write8(from);
1445 }
1446
1447 /* por m64 to r64 */
PORMtoR(int to,u32 from)1448 void PORMtoR(int to, u32 from) {
1449 write16(0xEB0F);
1450 ModRM(0, to, DISP32);
1451 write32(from);
1452 }
1453
1454 /* pxor m64 to r64 */
PXORMtoR(int to,u32 from)1455 void PXORMtoR(int to, u32 from) {
1456 write16(0xEF0F);
1457 ModRM(0, to, DISP32);
1458 write32(from);
1459 }
1460
1461 /* pand m64 to r64 */
PANDMtoR(int to,u32 from)1462 void PANDMtoR(int to, u32 from) {
1463 write16(0xDB0F);
1464 ModRM(0, to, DISP32);
1465 write32(from);
1466 }
1467
1468 /* pandn m64 to r64 */
PANDNMtoR(int to,u32 from)1469 void PANDNMtoR(int to, u32 from) {
1470 write16(0xDF0F);
1471 ModRM(0, to, DISP32);
1472 write32(from);
1473 }
1474
1475 /* movd m32 to r64 */
MOVDMtoR(int to,u32 from)1476 void MOVDMtoR(int to, u32 from) {
1477 write16(0x6E0F);
1478 ModRM(0, to, DISP32);
1479 write32(from);
1480 }
1481
1482 /* movq r64 to m32 */
MOVDRtoM(u32 to,int from)1483 void MOVDRtoM(u32 to, int from) {
1484 write16(0x7E0F);
1485 ModRM(0, from, DISP32);
1486 write32(to);
1487 }
1488
1489 /* movd r32 to r64 */
MOVD32RtoR(int to,int from)1490 void MOVD32RtoR(int to, int from) {
1491 write16(0x6E0F);
1492 ModRM(3, to,from);
1493 }
1494
1495 /* movq r64 to r32 */
MOVD64RtoR(int to,int from)1496 void MOVD64RtoR(int to, int from) {
1497 write16(0x7E0F);
1498 ModRM(3, from,to);
1499 }
1500
MOVQRtoR(int to,int from)1501 void MOVQRtoR(int to, int from) {
1502 write16(0x6F0F);
1503 ModRM(3, to,from);
1504 }
1505
PUNPCKHDQRtoR(int to,int from)1506 void PUNPCKHDQRtoR(int to, int from) {
1507 write16(0x6A0F);
1508 ModRM(3, to,from);
1509 }
1510
PUNPCKLDQRtoR(int to,int from)1511 void PUNPCKLDQRtoR(int to, int from) {
1512 write16(0x620F);
1513 ModRM(3, to,from);
1514 }
1515
1516 //////////////////////////////////////////////////////////////////////////
1517 // SSE intructions
1518 //////////////////////////////////////////////////////////////////////////
1519
MOVAPSMtoR(int to,int from)1520 void MOVAPSMtoR(int to, int from) {
1521 write16(0x280f);
1522 ModRM(0, to, DISP32);
1523 write32(from);
1524 }
1525
MOVAPSRtoM(int to,int from)1526 void MOVAPSRtoM(int to, int from) {
1527 write16(0x2b0f);
1528 ModRM(0, from, DISP32);
1529 write32(to);
1530 }
1531
MOVAPSRtoR(int to,int from)1532 void MOVAPSRtoR(int to, int from) {
1533 write16(0x290f);
1534 ModRM(3, to,from);
1535 }
1536
ORPSMtoR(int to,int from)1537 void ORPSMtoR(int to, int from) {
1538 write16(0x560f);
1539 ModRM(0, to, DISP32);
1540 write32(from);
1541 }
1542
ORPSRtoR(int to,int from)1543 void ORPSRtoR(int to, int from) {
1544 write16(0x560f);
1545 ModRM(3, to,from);
1546 }
1547
XORPSMtoR(int to,int from)1548 void XORPSMtoR(int to, int from) {
1549 write16(0x570f);
1550 ModRM(0, to, DISP32);
1551 write32(from);
1552 }
1553
XORPSRtoR(int to,int from)1554 void XORPSRtoR(int to, int from) {
1555 write16(0x570f);
1556 ModRM(3, to,from);
1557 }
1558
ANDPSMtoR(int to,int from)1559 void ANDPSMtoR(int to, int from) {
1560 write16(0x540f);
1561 ModRM(0, to, DISP32);
1562 write32(from);
1563 }
1564
ANDPSRtoR(int to,int from)1565 void ANDPSRtoR(int to, int from) {
1566 write16(0x540f);
1567 ModRM(3, to,from);
1568 }
1569
1570 /*
1571 3DNOW intructions
1572 */
1573
PFCMPEQMtoR(int to,int from)1574 void PFCMPEQMtoR(int to, int from) {
1575 write16(0x0f0f);
1576 ModRM(0, to, DISP32);
1577 write32(from);
1578 write8(0xb0);
1579 }
1580
PFCMPGTMtoR(int to,int from)1581 void PFCMPGTMtoR(int to, int from) {
1582 write16(0x0f0f);
1583 ModRM(0, to, DISP32);
1584 write32(from);
1585 write8(0xa0);
1586 }
1587
PFCMPGEMtoR(int to,int from)1588 void PFCMPGEMtoR(int to, int from) {
1589 write16(0x0f0f);
1590 ModRM(0, to, DISP32);
1591 write32(from);
1592 write8(0x90);
1593 }
1594
PFADDMtoR(int to,int from)1595 void PFADDMtoR(int to, int from) {
1596 write16(0x0f0f);
1597 ModRM(0, to, DISP32);
1598 write32(from);
1599 write8(0x9e);
1600 }
1601
PFADDRtoR(int to,int from)1602 void PFADDRtoR(int to, int from) {
1603 write16(0x0f0f);
1604 ModRM(3, to, from);
1605 write8(0x9e);
1606 }
1607
PFSUBMtoR(int to,int from)1608 void PFSUBMtoR(int to, int from) {
1609 write16(0x0f0f);
1610 ModRM(0, to, DISP32);
1611 write32(from);
1612 write8(0x9a);
1613 }
1614
PFSUBRtoR(int to,int from)1615 void PFSUBRtoR(int to, int from) {
1616 write16(0x0f0f);
1617 ModRM(3, to, from);
1618 write8(0x9a);
1619 }
1620
PFMULMtoR(int to,int from)1621 void PFMULMtoR(int to, int from) {
1622 write16(0x0f0f);
1623 ModRM(0, to, DISP32);
1624 write32(from);
1625 write8(0xb4);
1626 }
1627
PFMULRtoR(int to,int from)1628 void PFMULRtoR(int to, int from) {
1629 write16(0x0f0f);
1630 ModRM(3, to,from);
1631 write8(0xb4);
1632 }
1633
PFRCPMtoR(int to,int from)1634 void PFRCPMtoR(int to, int from) {
1635 write16(0x0f0f);
1636 ModRM(0, to, DISP32);
1637 write32(from);
1638 write8(0x96);
1639 }
1640
PFRCPRtoR(int to,int from)1641 void PFRCPRtoR(int to, int from) {
1642 write16(0x0f0f);
1643 ModRM(3, to,from);
1644 write8(0x96);
1645 }
1646
PFRCPIT1RtoR(int to,int from)1647 void PFRCPIT1RtoR(int to, int from) {
1648 write16(0x0f0f);
1649 ModRM(3, to,from);
1650 write8(0xa6);
1651 }
1652
PFRCPIT2RtoR(int to,int from)1653 void PFRCPIT2RtoR(int to, int from) {
1654 write16(0x0f0f);
1655 ModRM(3, to,from);
1656 write8(0xb6);
1657 }
1658
PFRSQRTRtoR(int to,int from)1659 void PFRSQRTRtoR(int to, int from) {
1660 write16(0x0f0f);
1661 ModRM(3, to,from);
1662 write8(0x97);
1663 }
1664
PFRSQIT1RtoR(int to,int from)1665 void PFRSQIT1RtoR(int to, int from) {
1666 write16(0x0f0f);
1667 ModRM(3, to,from);
1668 write8(0xa7);
1669 }
1670
PF2IDMtoR(int to,int from)1671 void PF2IDMtoR(int to, int from) {
1672 write16(0x0f0f);
1673 ModRM(0, to, DISP32);
1674 write32(from);
1675 write8(0x1d);
1676 }
1677
PF2IDRtoR(int to,int from)1678 void PF2IDRtoR(int to, int from) {
1679 write16(0x0f0f);
1680 ModRM(3, to, from);
1681 write8(0x1d);
1682 }
1683
PI2FDMtoR(int to,int from)1684 void PI2FDMtoR(int to, int from) {
1685 write16(0x0f0f);
1686 ModRM(0, to, DISP32);
1687 write32(from);
1688 write8(0x0d);
1689 }
1690
PI2FDRtoR(int to,int from)1691 void PI2FDRtoR(int to, int from) {
1692 write16(0x0f0f);
1693 ModRM(3, to, from);
1694 write8(0x0d);
1695 }
1696
1697 /*
1698 3DNOW Extension intructions
1699 */
1700
PFMAXMtoR(int to,int from)1701 void PFMAXMtoR(int to, int from) {
1702 write16(0x0f0f);
1703 ModRM(0, to, DISP32);
1704 write32(from);
1705 write8(0xa4);
1706 }
1707
PFMAXRtoR(int to,int from)1708 void PFMAXRtoR(int to, int from) {
1709 write16(0x0f0f);
1710 ModRM(3, to, from);
1711 write8(0xa4);
1712 }
1713
PFMINMtoR(int to,int from)1714 void PFMINMtoR(int to, int from) {
1715 write16(0x0f0f);
1716 ModRM(0, to, DISP32);
1717 write32(from);
1718 write8(0x94);
1719 }
1720
PFMINRtoR(int to,int from)1721 void PFMINRtoR(int to, int from) {
1722 write16(0x0f0f);
1723 ModRM(3, to, from);
1724 write8(0x94);
1725 }
1726
1727 #endif
1728