Commit | Line | Data |
---|---|---|
ef79bbde P |
1 | // stop compiling if NORECBUILD build (only for Visual Studio) |
2 | #if !(defined(_MSC_VER) && defined(PCSX2_NORECBUILD)) | |
3 | ||
4 | #include "ix86-64.h" | |
5 | ||
6 | #include <assert.h> | |
7 | ||
8 | /********************/ | |
9 | /* MMX instructions */ | |
10 | /********************/ | |
11 | ||
12 | // r64 = mm | |
13 | ||
14 | /* movq m64 to r64 */ | |
15 | void MOVQMtoR( x86MMXRegType to, uptr from ) | |
16 | { | |
17 | MEMADDR_OP(0, VAROP2(0x0F, 0x6F), true, to, from, 0); | |
18 | } | |
19 | ||
20 | /* movq r64 to m64 */ | |
21 | void MOVQRtoM( uptr to, x86MMXRegType from ) | |
22 | { | |
23 | MEMADDR_OP(0, VAROP2(0x0F, 0x7F), true, from, to, 0); | |
24 | } | |
25 | ||
26 | /* pand r64 to r64 */ | |
27 | void PANDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
28 | { | |
29 | RexRB(0, to, from); | |
30 | write16( 0xDB0F ); | |
31 | ModRM( 3, to, from ); | |
32 | } | |
33 | ||
34 | void PANDNRtoR( x86MMXRegType to, x86MMXRegType from ) | |
35 | { | |
36 | RexRB(0, to, from); | |
37 | write16( 0xDF0F ); | |
38 | ModRM( 3, to, from ); | |
39 | } | |
40 | ||
41 | /* por r64 to r64 */ | |
42 | void PORRtoR( x86MMXRegType to, x86MMXRegType from ) | |
43 | { | |
44 | RexRB(0, to, from); | |
45 | write16( 0xEB0F ); | |
46 | ModRM( 3, to, from ); | |
47 | } | |
48 | ||
49 | /* pxor r64 to r64 */ | |
50 | void PXORRtoR( x86MMXRegType to, x86MMXRegType from ) | |
51 | { | |
52 | RexRB(0, to, from); | |
53 | write16( 0xEF0F ); | |
54 | ModRM( 3, to, from ); | |
55 | } | |
56 | ||
57 | /* psllq r64 to r64 */ | |
58 | void PSLLQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
59 | { | |
60 | RexRB(0, to, from); | |
61 | write16( 0xF30F ); | |
62 | ModRM( 3, to, from ); | |
63 | } | |
64 | ||
65 | /* psllq m64 to r64 */ | |
66 | void PSLLQMtoR( x86MMXRegType to, uptr from ) | |
67 | { | |
68 | MEMADDR_OP(0, VAROP2(0x0F, 0xF3), true, to, from, 0); | |
69 | } | |
70 | ||
71 | /* psllq imm8 to r64 */ | |
72 | void PSLLQItoR( x86MMXRegType to, u8 from ) | |
73 | { | |
74 | RexB(0, to); | |
75 | write16( 0x730F ); | |
76 | ModRM( 3, 6, to); | |
77 | write8( from ); | |
78 | } | |
79 | ||
80 | /* psrlq r64 to r64 */ | |
81 | void PSRLQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
82 | { | |
83 | RexRB(0, to, from); | |
84 | write16( 0xD30F ); | |
85 | ModRM( 3, to, from ); | |
86 | } | |
87 | ||
88 | /* psrlq m64 to r64 */ | |
89 | void PSRLQMtoR( x86MMXRegType to, uptr from ) | |
90 | { | |
91 | MEMADDR_OP(0, VAROP2(0x0F, 0xD3), true, to, from, 0); | |
92 | } | |
93 | ||
94 | /* psrlq imm8 to r64 */ | |
95 | void PSRLQItoR( x86MMXRegType to, u8 from ) | |
96 | { | |
97 | RexB(0, to); | |
98 | write16( 0x730F ); | |
99 | ModRM( 3, 2, to); | |
100 | write8( from ); | |
101 | } | |
102 | ||
103 | /* paddusb r64 to r64 */ | |
104 | void PADDUSBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
105 | { | |
106 | RexRB(0, to, from); | |
107 | write16( 0xDC0F ); | |
108 | ModRM( 3, to, from ); | |
109 | } | |
110 | ||
111 | /* paddusb m64 to r64 */ | |
112 | void PADDUSBMtoR( x86MMXRegType to, uptr from ) | |
113 | { | |
114 | MEMADDR_OP(0, VAROP2(0x0F, 0xDC), true, to, from, 0); | |
115 | } | |
116 | ||
117 | /* paddusw r64 to r64 */ | |
118 | void PADDUSWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
119 | { | |
120 | RexRB(0, to, from); | |
121 | write16( 0xDD0F ); | |
122 | ModRM( 3, to, from ); | |
123 | } | |
124 | ||
125 | /* paddusw m64 to r64 */ | |
126 | void PADDUSWMtoR( x86MMXRegType to, uptr from ) | |
127 | { | |
128 | MEMADDR_OP(0, VAROP2(0x0F, 0xDD), true, to, from, 0); | |
129 | } | |
130 | ||
131 | /* paddb r64 to r64 */ | |
132 | void PADDBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
133 | { | |
134 | RexRB(0, to, from); | |
135 | write16( 0xFC0F ); | |
136 | ModRM( 3, to, from ); | |
137 | } | |
138 | ||
139 | /* paddb m64 to r64 */ | |
140 | void PADDBMtoR( x86MMXRegType to, uptr from ) | |
141 | { | |
142 | MEMADDR_OP(0, VAROP2(0x0F, 0xFC), true, to, from, 0); | |
143 | } | |
144 | ||
145 | /* paddw r64 to r64 */ | |
146 | void PADDWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
147 | { | |
148 | RexRB(0, to, from); | |
149 | write16( 0xFD0F ); | |
150 | ModRM( 3, to, from ); | |
151 | } | |
152 | ||
153 | /* paddw m64 to r64 */ | |
154 | void PADDWMtoR( x86MMXRegType to, uptr from ) | |
155 | { | |
156 | MEMADDR_OP(0, VAROP2(0x0F, 0xFD), true, to, from, 0); | |
157 | } | |
158 | ||
159 | /* paddd r64 to r64 */ | |
160 | void PADDDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
161 | { | |
162 | RexRB(0, to, from); | |
163 | write16( 0xFE0F ); | |
164 | ModRM( 3, to, from ); | |
165 | } | |
166 | ||
167 | /* paddd m64 to r64 */ | |
168 | void PADDDMtoR( x86MMXRegType to, uptr from ) | |
169 | { | |
170 | MEMADDR_OP(0, VAROP2(0x0F, 0xFE), true, to, from, 0); | |
171 | } | |
172 | ||
173 | /* emms */ | |
174 | void EMMS( void ) | |
175 | { | |
176 | write16( 0x770F ); | |
177 | } | |
178 | ||
179 | void PADDSBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
180 | { | |
181 | RexRB(0, to, from); | |
182 | write16( 0xEC0F ); | |
183 | ModRM( 3, to, from ); | |
184 | } | |
185 | ||
186 | void PADDSWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
187 | { | |
188 | RexRB(0, to, from); | |
189 | write16( 0xED0F ); | |
190 | ModRM( 3, to, from ); | |
191 | } | |
192 | ||
193 | // paddq m64 to r64 (sse2 only?) | |
194 | void PADDQMtoR( x86MMXRegType to, uptr from ) | |
195 | { | |
196 | MEMADDR_OP(0, VAROP2(0x0F, 0xD4), true, to, from, 0); | |
197 | } | |
198 | ||
199 | // paddq r64 to r64 (sse2 only?) | |
200 | void PADDQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
201 | { | |
202 | RexRB(0, to, from); | |
203 | write16( 0xD40F ); | |
204 | ModRM( 3, to, from ); | |
205 | } | |
206 | ||
207 | void PSUBSBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
208 | { | |
209 | RexRB(0, to, from); | |
210 | write16( 0xE80F ); | |
211 | ModRM( 3, to, from ); | |
212 | } | |
213 | ||
214 | void PSUBSWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
215 | { | |
216 | RexRB(0, to, from); | |
217 | write16( 0xE90F ); | |
218 | ModRM( 3, to, from ); | |
219 | } | |
220 | ||
221 | ||
222 | void PSUBBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
223 | { | |
224 | RexRB(0, to, from); | |
225 | write16( 0xF80F ); | |
226 | ModRM( 3, to, from ); | |
227 | } | |
228 | ||
229 | void PSUBWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
230 | { | |
231 | RexRB(0, to, from); | |
232 | write16( 0xF90F ); | |
233 | ModRM( 3, to, from ); | |
234 | } | |
235 | ||
236 | void PSUBDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
237 | { | |
238 | RexRB(0, to, from); | |
239 | write16( 0xFA0F ); | |
240 | ModRM( 3, to, from ); | |
241 | } | |
242 | ||
243 | void PSUBDMtoR( x86MMXRegType to, uptr from ) | |
244 | { | |
245 | MEMADDR_OP(0, VAROP2(0x0F, 0xFA), true, to, from, 0); | |
246 | } | |
247 | ||
248 | void PSUBUSBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
249 | { | |
250 | RexRB(0, to, from); | |
251 | write16( 0xD80F ); | |
252 | ModRM( 3, to, from ); | |
253 | } | |
254 | ||
255 | void PSUBUSWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
256 | { | |
257 | RexRB(0, to, from); | |
258 | write16( 0xD90F ); | |
259 | ModRM( 3, to, from ); | |
260 | } | |
261 | ||
262 | // psubq m64 to r64 (sse2 only?) | |
263 | void PSUBQMtoR( x86MMXRegType to, uptr from ) | |
264 | { | |
265 | MEMADDR_OP(0, VAROP2(0x0F, 0xFB), true, to, from, 0); | |
266 | } | |
267 | ||
268 | // psubq r64 to r64 (sse2 only?) | |
269 | void PSUBQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
270 | { | |
271 | RexRB(0, to, from); | |
272 | write16( 0xFB0F ); | |
273 | ModRM( 3, to, from ); | |
274 | } | |
275 | ||
276 | // pmuludq m64 to r64 (sse2 only?) | |
277 | void PMULUDQMtoR( x86MMXRegType to, uptr from ) | |
278 | { | |
279 | MEMADDR_OP(0, VAROP2(0x0F, 0xF4), true, to, from, 0); | |
280 | } | |
281 | ||
282 | // pmuludq r64 to r64 (sse2 only?) | |
283 | void PMULUDQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
284 | { | |
285 | RexRB(0, to, from); | |
286 | write16( 0xF40F ); | |
287 | ModRM( 3, to, from ); | |
288 | } | |
289 | ||
290 | void PCMPEQBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
291 | { | |
292 | RexRB(0, to, from); | |
293 | write16( 0x740F ); | |
294 | ModRM( 3, to, from ); | |
295 | } | |
296 | ||
297 | void PCMPEQWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
298 | { | |
299 | RexRB(0, to, from); | |
300 | write16( 0x750F ); | |
301 | ModRM( 3, to, from ); | |
302 | } | |
303 | ||
304 | void PCMPEQDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
305 | { | |
306 | RexRB(0, to, from); | |
307 | write16( 0x760F ); | |
308 | ModRM( 3, to, from ); | |
309 | } | |
310 | ||
311 | void PCMPEQDMtoR( x86MMXRegType to, uptr from ) | |
312 | { | |
313 | MEMADDR_OP(0, VAROP2(0x0F, 0x76), true, to, from, 0); | |
314 | } | |
315 | ||
316 | void PCMPGTBRtoR( x86MMXRegType to, x86MMXRegType from ) | |
317 | { | |
318 | RexRB(0, to, from); | |
319 | write16( 0x640F ); | |
320 | ModRM( 3, to, from ); | |
321 | } | |
322 | ||
323 | void PCMPGTWRtoR( x86MMXRegType to, x86MMXRegType from ) | |
324 | { | |
325 | RexRB(0, to, from); | |
326 | write16( 0x650F ); | |
327 | ModRM( 3, to, from ); | |
328 | } | |
329 | ||
330 | void PCMPGTDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
331 | { | |
332 | RexRB(0, to, from); | |
333 | write16( 0x660F ); | |
334 | ModRM( 3, to, from ); | |
335 | } | |
336 | ||
337 | void PCMPGTDMtoR( x86MMXRegType to, uptr from ) | |
338 | { | |
339 | MEMADDR_OP(0, VAROP2(0x0F, 0x66), true, to, from, 0); | |
340 | } | |
341 | ||
342 | void PSRLWItoR( x86MMXRegType to, u8 from ) | |
343 | { | |
344 | RexB(0, to); | |
345 | write16( 0x710F ); | |
346 | ModRM( 3, 2 , to ); | |
347 | write8( from ); | |
348 | } | |
349 | ||
350 | void PSRLDItoR( x86MMXRegType to, u8 from ) | |
351 | { | |
352 | RexB(0, to); | |
353 | write16( 0x720F ); | |
354 | ModRM( 3, 2 , to ); | |
355 | write8( from ); | |
356 | } | |
357 | ||
358 | void PSRLDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
359 | { | |
360 | RexRB(0, to, from); | |
361 | write16( 0xD20F ); | |
362 | ModRM( 3, to, from ); | |
363 | } | |
364 | ||
365 | void PSLLWItoR( x86MMXRegType to, u8 from ) | |
366 | { | |
367 | RexB(0, to); | |
368 | write16( 0x710F ); | |
369 | ModRM( 3, 6 , to ); | |
370 | write8( from ); | |
371 | } | |
372 | ||
373 | void PSLLDItoR( x86MMXRegType to, u8 from ) | |
374 | { | |
375 | RexB(0, to); | |
376 | write16( 0x720F ); | |
377 | ModRM( 3, 6 , to ); | |
378 | write8( from ); | |
379 | } | |
380 | ||
381 | void PSLLDRtoR( x86MMXRegType to, x86MMXRegType from ) | |
382 | { | |
383 | RexRB(0, to, from); | |
384 | write16( 0xF20F ); | |
385 | ModRM( 3, to, from ); | |
386 | } | |
387 | ||
388 | void PSRAWItoR( x86MMXRegType to, u8 from ) | |
389 | { | |
390 | RexB(0, to); | |
391 | write16( 0x710F ); | |
392 | ModRM( 3, 4 , to ); | |
393 | write8( from ); | |
394 | } | |
395 | ||
396 | void PSRADItoR( x86MMXRegType to, u8 from ) | |
397 | { | |
398 | RexB(0, to); | |
399 | write16( 0x720F ); | |
400 | ModRM( 3, 4 , to ); | |
401 | write8( from ); | |
402 | } | |
403 | ||
404 | void PSRADRtoR( x86MMXRegType to, x86MMXRegType from ) | |
405 | { | |
406 | RexRB(0, to, from); | |
407 | write16( 0xE20F ); | |
408 | ModRM( 3, to, from ); | |
409 | } | |
410 | ||
411 | /* por m64 to r64 */ | |
412 | void PORMtoR( x86MMXRegType to, uptr from ) | |
413 | { | |
414 | MEMADDR_OP(0, VAROP2(0x0F, 0xEB), true, to, from, 0); | |
415 | } | |
416 | ||
417 | /* pxor m64 to r64 */ | |
418 | void PXORMtoR( x86MMXRegType to, uptr from ) | |
419 | { | |
420 | MEMADDR_OP(0, VAROP2(0x0F, 0xEF), true, to, from, 0); | |
421 | } | |
422 | ||
423 | /* pand m64 to r64 */ | |
424 | void PANDMtoR( x86MMXRegType to, uptr from ) | |
425 | { | |
426 | MEMADDR_OP(0, VAROP2(0x0F, 0xDB), true, to, from, 0); | |
427 | } | |
428 | ||
429 | void PANDNMtoR( x86MMXRegType to, uptr from ) | |
430 | { | |
431 | MEMADDR_OP(0, VAROP2(0x0F, 0xDF), true, to, from, 0); | |
432 | } | |
433 | ||
434 | void PUNPCKHDQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
435 | { | |
436 | RexRB(0, to, from); | |
437 | write16( 0x6A0F ); | |
438 | ModRM( 3, to, from ); | |
439 | } | |
440 | ||
441 | void PUNPCKHDQMtoR( x86MMXRegType to, uptr from ) | |
442 | { | |
443 | MEMADDR_OP(0, VAROP2(0x0F, 0x6A), true, to, from, 0); | |
444 | } | |
445 | ||
446 | void PUNPCKLDQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
447 | { | |
448 | RexRB(0, to, from); | |
449 | write16( 0x620F ); | |
450 | ModRM( 3, to, from ); | |
451 | } | |
452 | ||
453 | void PUNPCKLDQMtoR( x86MMXRegType to, uptr from ) | |
454 | { | |
455 | MEMADDR_OP(0, VAROP2(0x0F, 0x62), true, to, from, 0); | |
456 | } | |
457 | ||
458 | void MOVQ64ItoR( x86MMXRegType reg, u64 i ) | |
459 | { | |
460 | RexR(0, reg); | |
461 | write16(0x6F0F); | |
462 | ModRM(0, reg, DISP32); | |
463 | write32(2); | |
464 | JMP8( 8 ); | |
465 | write64( i ); | |
466 | } | |
467 | ||
468 | void MOVQRtoR( x86MMXRegType to, x86MMXRegType from ) | |
469 | { | |
470 | RexRB(0, to, from); | |
471 | write16( 0x6F0F ); | |
472 | ModRM( 3, to, from ); | |
473 | } | |
474 | ||
475 | void MOVQRmtoROffset( x86MMXRegType to, x86IntRegType from, u32 offset ) | |
476 | { | |
477 | RexRB(0, to, from); | |
478 | write16( 0x6F0F ); | |
479 | ||
480 | if( offset < 128 ) { | |
481 | ModRM( 1, to, from ); | |
482 | write8(offset); | |
483 | } | |
484 | else { | |
485 | ModRM( 2, to, from ); | |
486 | write32(offset); | |
487 | } | |
488 | } | |
489 | ||
490 | void MOVQRtoRmOffset( x86IntRegType to, x86MMXRegType from, u32 offset ) | |
491 | { | |
492 | RexRB(0, from, to); | |
493 | write16( 0x7F0F ); | |
494 | ||
495 | if( offset < 128 ) { | |
496 | ModRM( 1, from , to ); | |
497 | write8(offset); | |
498 | } | |
499 | else { | |
500 | ModRM( 2, from, to ); | |
501 | write32(offset); | |
502 | } | |
503 | } | |
504 | ||
505 | /* movd m32 to r64 */ | |
506 | void MOVDMtoMMX( x86MMXRegType to, uptr from ) | |
507 | { | |
508 | MEMADDR_OP(0, VAROP2(0x0F, 0x6E), true, to, from, 0); | |
509 | } | |
510 | ||
511 | /* movd r64 to m32 */ | |
512 | void MOVDMMXtoM( uptr to, x86MMXRegType from ) | |
513 | { | |
514 | MEMADDR_OP(0, VAROP2(0x0F, 0x7E), true, from, to, 0); | |
515 | } | |
516 | ||
517 | void MOVD32RtoMMX( x86MMXRegType to, x86IntRegType from ) | |
518 | { | |
519 | RexRB(0, to, from); | |
520 | write16( 0x6E0F ); | |
521 | ModRM( 3, to, from ); | |
522 | } | |
523 | ||
524 | void MOVD32RmtoMMX( x86MMXRegType to, x86IntRegType from ) | |
525 | { | |
526 | RexRB(0, to, from); | |
527 | write16( 0x6E0F ); | |
528 | ModRM( 0, to, from ); | |
529 | } | |
530 | ||
531 | void MOVD32RmOffsettoMMX( x86MMXRegType to, x86IntRegType from, u32 offset ) | |
532 | { | |
533 | RexRB(0, to, from); | |
534 | write16( 0x6E0F ); | |
535 | ||
536 | if( offset < 128 ) { | |
537 | ModRM( 1, to, from ); | |
538 | write8(offset); | |
539 | } | |
540 | else { | |
541 | ModRM( 2, to, from ); | |
542 | write32(offset); | |
543 | } | |
544 | } | |
545 | ||
546 | void MOVD32MMXtoR( x86IntRegType to, x86MMXRegType from ) | |
547 | { | |
548 | RexRB(0, from, to); | |
549 | write16( 0x7E0F ); | |
550 | ModRM( 3, from, to ); | |
551 | } | |
552 | ||
553 | void MOVD32MMXtoRm( x86IntRegType to, x86MMXRegType from ) | |
554 | { | |
555 | RexRB(0, from, to); | |
556 | write16( 0x7E0F ); | |
557 | ModRM( 0, from, to ); | |
558 | if( to >= 4 ) { | |
559 | // no idea why | |
560 | assert( to == ESP ); | |
561 | write8(0x24); | |
562 | } | |
563 | ||
564 | } | |
565 | ||
566 | void MOVD32MMXtoRmOffset( x86IntRegType to, x86MMXRegType from, u32 offset ) | |
567 | { | |
568 | RexRB(0, from, to); | |
569 | write16( 0x7E0F ); | |
570 | ||
571 | if( offset < 128 ) { | |
572 | ModRM( 1, from, to ); | |
573 | write8(offset); | |
574 | } | |
575 | else { | |
576 | ModRM( 2, from, to ); | |
577 | write32(offset); | |
578 | } | |
579 | } | |
580 | ||
581 | ///* movd r32 to r64 */ | |
582 | //void MOVD32MMXtoMMX( x86MMXRegType to, x86MMXRegType from ) | |
583 | //{ | |
584 | // write16( 0x6E0F ); | |
585 | // ModRM( 3, to, from ); | |
586 | //} | |
587 | // | |
588 | ///* movq r64 to r32 */ | |
589 | //void MOVD64MMXtoMMX( x86MMXRegType to, x86MMXRegType from ) | |
590 | //{ | |
591 | // write16( 0x7E0F ); | |
592 | // ModRM( 3, from, to ); | |
593 | //} | |
594 | ||
595 | // untested | |
596 | void PACKSSWBMMXtoMMX(x86MMXRegType to, x86MMXRegType from) | |
597 | { | |
598 | RexRB(0, to, from); | |
599 | write16( 0x630F ); | |
600 | ModRM( 3, to, from ); | |
601 | } | |
602 | ||
603 | void PACKSSDWMMXtoMMX(x86MMXRegType to, x86MMXRegType from) | |
604 | { | |
605 | RexRB(0, to, from); | |
606 | write16( 0x6B0F ); | |
607 | ModRM( 3, to, from ); | |
608 | } | |
609 | ||
610 | void PMOVMSKBMMXtoR(x86IntRegType to, x86MMXRegType from) | |
611 | { | |
612 | RexRB(0, to, from); | |
613 | write16( 0xD70F ); | |
614 | ModRM( 3, to, from ); | |
615 | } | |
616 | ||
617 | void PINSRWRtoMMX( x86MMXRegType to, x86SSERegType from, u8 imm8 ) | |
618 | { | |
619 | RexRB(0, to, from); | |
620 | write16( 0xc40f ); | |
621 | ModRM( 3, to, from ); | |
622 | write8( imm8 ); | |
623 | } | |
624 | ||
625 | void PSHUFWRtoR(x86MMXRegType to, x86MMXRegType from, u8 imm8) | |
626 | { | |
627 | RexRB(0, to, from); | |
628 | write16(0x700f); | |
629 | ModRM( 3, to, from ); | |
630 | write8(imm8); | |
631 | } | |
632 | ||
633 | void PSHUFWMtoR(x86MMXRegType to, uptr from, u8 imm8) | |
634 | { | |
635 | MEMADDR_OP(0, VAROP2(0x0F, 0x70), true, to, from, 1 /* XXX was 0? */); | |
636 | write8(imm8); | |
637 | } | |
638 | ||
639 | void MASKMOVQRtoR(x86MMXRegType to, x86MMXRegType from) | |
640 | { | |
641 | RexRB(0, to, from); | |
642 | write16(0xf70f); | |
643 | ModRM( 3, to, from ); | |
644 | } | |
645 | ||
646 | #endif |