asmkit/x86/features/
MMX.rs

1use super::super::opcodes::*;
2use crate::core::emitter::*;
3use crate::core::operand::*;
4use crate::x86::assembler::*;
5use crate::x86::operands::*;
6
7/// A dummy operand that represents no register. Here just for simplicity.
8const NOREG: Operand = Operand::new();
9
10/// `MMX_EMMS`.
11///
12/// Supported operand variants:
13///
14/// ```text
15/// +---+----------+
16/// | # | Operands |
17/// +---+----------+
18/// | 1 | (none)   |
19/// +---+----------+
20/// ```
21pub trait MmxEmmsEmitter {
22    fn mmx_emms(&mut self);
23}
24
25impl<'a> MmxEmmsEmitter for Assembler<'a> {
26    fn mmx_emms(&mut self) {
27        self.emit(MMX_EMMS, &NOREG, &NOREG, &NOREG, &NOREG);
28    }
29}
30
31/// `MMX_MOVD_G2M`.
32///
33/// Supported operand variants:
34///
35/// ```text
36/// +---+----------+
37/// | # | Operands |
38/// +---+----------+
39/// | 1 | Mm, Gpd  |
40/// | 2 | Mm, Mem  |
41/// +---+----------+
42/// ```
43pub trait MmxMovdG2mEmitter<A, B> {
44    fn mmx_movd_g2m(&mut self, op0: A, op1: B);
45}
46
47impl<'a> MmxMovdG2mEmitter<Mm, Gpd> for Assembler<'a> {
48    fn mmx_movd_g2m(&mut self, op0: Mm, op1: Gpd) {
49        self.emit(
50            MMX_MOVD_G2MRR,
51            op0.as_operand(),
52            op1.as_operand(),
53            &NOREG,
54            &NOREG,
55        );
56    }
57}
58
59impl<'a> MmxMovdG2mEmitter<Mm, Mem> for Assembler<'a> {
60    fn mmx_movd_g2m(&mut self, op0: Mm, op1: Mem) {
61        self.emit(
62            MMX_MOVD_G2MRM,
63            op0.as_operand(),
64            op1.as_operand(),
65            &NOREG,
66            &NOREG,
67        );
68    }
69}
70
71/// `MMX_MOVD_M2G`.
72///
73/// Supported operand variants:
74///
75/// ```text
76/// +---+----------+
77/// | # | Operands |
78/// +---+----------+
79/// | 1 | Gpd, Mm  |
80/// | 2 | Mem, Mm  |
81/// +---+----------+
82/// ```
83pub trait MmxMovdM2gEmitter<A, B> {
84    fn mmx_movd_m2g(&mut self, op0: A, op1: B);
85}
86
87impl<'a> MmxMovdM2gEmitter<Gpd, Mm> for Assembler<'a> {
88    fn mmx_movd_m2g(&mut self, op0: Gpd, op1: Mm) {
89        self.emit(
90            MMX_MOVD_M2GRR,
91            op0.as_operand(),
92            op1.as_operand(),
93            &NOREG,
94            &NOREG,
95        );
96    }
97}
98
99impl<'a> MmxMovdM2gEmitter<Mem, Mm> for Assembler<'a> {
100    fn mmx_movd_m2g(&mut self, op0: Mem, op1: Mm) {
101        self.emit(
102            MMX_MOVD_M2GMR,
103            op0.as_operand(),
104            op1.as_operand(),
105            &NOREG,
106            &NOREG,
107        );
108    }
109}
110
111/// `MMX_MOVQ`.
112///
113/// Supported operand variants:
114///
115/// ```text
116/// +---+----------+
117/// | # | Operands |
118/// +---+----------+
119/// | 1 | Mem, Mm  |
120/// | 2 | Mm, Mem  |
121/// | 3 | Mm, Mm   |
122/// +---+----------+
123/// ```
124pub trait MmxMovqEmitter<A, B> {
125    fn mmx_movq(&mut self, op0: A, op1: B);
126}
127
128impl<'a> MmxMovqEmitter<Mm, Mm> for Assembler<'a> {
129    fn mmx_movq(&mut self, op0: Mm, op1: Mm) {
130        self.emit(
131            MMX_MOVQRR,
132            op0.as_operand(),
133            op1.as_operand(),
134            &NOREG,
135            &NOREG,
136        );
137    }
138}
139
140impl<'a> MmxMovqEmitter<Mm, Mem> for Assembler<'a> {
141    fn mmx_movq(&mut self, op0: Mm, op1: Mem) {
142        self.emit(
143            MMX_MOVQRM,
144            op0.as_operand(),
145            op1.as_operand(),
146            &NOREG,
147            &NOREG,
148        );
149    }
150}
151
152impl<'a> MmxMovqEmitter<Mem, Mm> for Assembler<'a> {
153    fn mmx_movq(&mut self, op0: Mem, op1: Mm) {
154        self.emit(
155            MMX_MOVQMR,
156            op0.as_operand(),
157            op1.as_operand(),
158            &NOREG,
159            &NOREG,
160        );
161    }
162}
163
164/// `MMX_MOVQ_G2M`.
165///
166/// Supported operand variants:
167///
168/// ```text
169/// +---+----------+
170/// | # | Operands |
171/// +---+----------+
172/// | 1 | Mm, Gpd  |
173/// | 2 | Mm, Mem  |
174/// +---+----------+
175/// ```
176pub trait MmxMovqG2mEmitter<A, B> {
177    fn mmx_movq_g2m(&mut self, op0: A, op1: B);
178}
179
180impl<'a> MmxMovqG2mEmitter<Mm, Gpd> for Assembler<'a> {
181    fn mmx_movq_g2m(&mut self, op0: Mm, op1: Gpd) {
182        self.emit(
183            MMX_MOVQ_G2MRR,
184            op0.as_operand(),
185            op1.as_operand(),
186            &NOREG,
187            &NOREG,
188        );
189    }
190}
191
192impl<'a> MmxMovqG2mEmitter<Mm, Mem> for Assembler<'a> {
193    fn mmx_movq_g2m(&mut self, op0: Mm, op1: Mem) {
194        self.emit(
195            MMX_MOVQ_G2MRM,
196            op0.as_operand(),
197            op1.as_operand(),
198            &NOREG,
199            &NOREG,
200        );
201    }
202}
203
204/// `MMX_MOVQ_M2G`.
205///
206/// Supported operand variants:
207///
208/// ```text
209/// +---+----------+
210/// | # | Operands |
211/// +---+----------+
212/// | 1 | Gpd, Mm  |
213/// | 2 | Mem, Mm  |
214/// +---+----------+
215/// ```
216pub trait MmxMovqM2gEmitter<A, B> {
217    fn mmx_movq_m2g(&mut self, op0: A, op1: B);
218}
219
220impl<'a> MmxMovqM2gEmitter<Gpd, Mm> for Assembler<'a> {
221    fn mmx_movq_m2g(&mut self, op0: Gpd, op1: Mm) {
222        self.emit(
223            MMX_MOVQ_M2GRR,
224            op0.as_operand(),
225            op1.as_operand(),
226            &NOREG,
227            &NOREG,
228        );
229    }
230}
231
232impl<'a> MmxMovqM2gEmitter<Mem, Mm> for Assembler<'a> {
233    fn mmx_movq_m2g(&mut self, op0: Mem, op1: Mm) {
234        self.emit(
235            MMX_MOVQ_M2GMR,
236            op0.as_operand(),
237            op1.as_operand(),
238            &NOREG,
239            &NOREG,
240        );
241    }
242}
243
244/// `MMX_PACKSSDW`.
245///
246/// Supported operand variants:
247///
248/// ```text
249/// +---+----------+
250/// | # | Operands |
251/// +---+----------+
252/// | 1 | Mm, Mem  |
253/// | 2 | Mm, Mm   |
254/// +---+----------+
255/// ```
256pub trait MmxPackssdwEmitter<A, B> {
257    fn mmx_packssdw(&mut self, op0: A, op1: B);
258}
259
260impl<'a> MmxPackssdwEmitter<Mm, Mm> for Assembler<'a> {
261    fn mmx_packssdw(&mut self, op0: Mm, op1: Mm) {
262        self.emit(
263            MMX_PACKSSDWRR,
264            op0.as_operand(),
265            op1.as_operand(),
266            &NOREG,
267            &NOREG,
268        );
269    }
270}
271
272impl<'a> MmxPackssdwEmitter<Mm, Mem> for Assembler<'a> {
273    fn mmx_packssdw(&mut self, op0: Mm, op1: Mem) {
274        self.emit(
275            MMX_PACKSSDWRM,
276            op0.as_operand(),
277            op1.as_operand(),
278            &NOREG,
279            &NOREG,
280        );
281    }
282}
283
284/// `MMX_PACKSSWB`.
285///
286/// Supported operand variants:
287///
288/// ```text
289/// +---+----------+
290/// | # | Operands |
291/// +---+----------+
292/// | 1 | Mm, Mem  |
293/// | 2 | Mm, Mm   |
294/// +---+----------+
295/// ```
296pub trait MmxPacksswbEmitter<A, B> {
297    fn mmx_packsswb(&mut self, op0: A, op1: B);
298}
299
300impl<'a> MmxPacksswbEmitter<Mm, Mm> for Assembler<'a> {
301    fn mmx_packsswb(&mut self, op0: Mm, op1: Mm) {
302        self.emit(
303            MMX_PACKSSWBRR,
304            op0.as_operand(),
305            op1.as_operand(),
306            &NOREG,
307            &NOREG,
308        );
309    }
310}
311
312impl<'a> MmxPacksswbEmitter<Mm, Mem> for Assembler<'a> {
313    fn mmx_packsswb(&mut self, op0: Mm, op1: Mem) {
314        self.emit(
315            MMX_PACKSSWBRM,
316            op0.as_operand(),
317            op1.as_operand(),
318            &NOREG,
319            &NOREG,
320        );
321    }
322}
323
324/// `MMX_PACKUSWB`.
325///
326/// Supported operand variants:
327///
328/// ```text
329/// +---+----------+
330/// | # | Operands |
331/// +---+----------+
332/// | 1 | Mm, Mem  |
333/// | 2 | Mm, Mm   |
334/// +---+----------+
335/// ```
336pub trait MmxPackuswbEmitter<A, B> {
337    fn mmx_packuswb(&mut self, op0: A, op1: B);
338}
339
340impl<'a> MmxPackuswbEmitter<Mm, Mm> for Assembler<'a> {
341    fn mmx_packuswb(&mut self, op0: Mm, op1: Mm) {
342        self.emit(
343            MMX_PACKUSWBRR,
344            op0.as_operand(),
345            op1.as_operand(),
346            &NOREG,
347            &NOREG,
348        );
349    }
350}
351
352impl<'a> MmxPackuswbEmitter<Mm, Mem> for Assembler<'a> {
353    fn mmx_packuswb(&mut self, op0: Mm, op1: Mem) {
354        self.emit(
355            MMX_PACKUSWBRM,
356            op0.as_operand(),
357            op1.as_operand(),
358            &NOREG,
359            &NOREG,
360        );
361    }
362}
363
364/// `MMX_PADDB`.
365///
366/// Supported operand variants:
367///
368/// ```text
369/// +---+----------+
370/// | # | Operands |
371/// +---+----------+
372/// | 1 | Mm, Mem  |
373/// | 2 | Mm, Mm   |
374/// +---+----------+
375/// ```
376pub trait MmxPaddbEmitter<A, B> {
377    fn mmx_paddb(&mut self, op0: A, op1: B);
378}
379
380impl<'a> MmxPaddbEmitter<Mm, Mm> for Assembler<'a> {
381    fn mmx_paddb(&mut self, op0: Mm, op1: Mm) {
382        self.emit(
383            MMX_PADDBRR,
384            op0.as_operand(),
385            op1.as_operand(),
386            &NOREG,
387            &NOREG,
388        );
389    }
390}
391
392impl<'a> MmxPaddbEmitter<Mm, Mem> for Assembler<'a> {
393    fn mmx_paddb(&mut self, op0: Mm, op1: Mem) {
394        self.emit(
395            MMX_PADDBRM,
396            op0.as_operand(),
397            op1.as_operand(),
398            &NOREG,
399            &NOREG,
400        );
401    }
402}
403
404/// `MMX_PADDD`.
405///
406/// Supported operand variants:
407///
408/// ```text
409/// +---+----------+
410/// | # | Operands |
411/// +---+----------+
412/// | 1 | Mm, Mem  |
413/// | 2 | Mm, Mm   |
414/// +---+----------+
415/// ```
416pub trait MmxPadddEmitter<A, B> {
417    fn mmx_paddd(&mut self, op0: A, op1: B);
418}
419
420impl<'a> MmxPadddEmitter<Mm, Mm> for Assembler<'a> {
421    fn mmx_paddd(&mut self, op0: Mm, op1: Mm) {
422        self.emit(
423            MMX_PADDDRR,
424            op0.as_operand(),
425            op1.as_operand(),
426            &NOREG,
427            &NOREG,
428        );
429    }
430}
431
432impl<'a> MmxPadddEmitter<Mm, Mem> for Assembler<'a> {
433    fn mmx_paddd(&mut self, op0: Mm, op1: Mem) {
434        self.emit(
435            MMX_PADDDRM,
436            op0.as_operand(),
437            op1.as_operand(),
438            &NOREG,
439            &NOREG,
440        );
441    }
442}
443
444/// `MMX_PADDQ`.
445///
446/// Supported operand variants:
447///
448/// ```text
449/// +---+----------+
450/// | # | Operands |
451/// +---+----------+
452/// | 1 | Mm, Mem  |
453/// | 2 | Mm, Mm   |
454/// +---+----------+
455/// ```
456pub trait MmxPaddqEmitter<A, B> {
457    fn mmx_paddq(&mut self, op0: A, op1: B);
458}
459
460impl<'a> MmxPaddqEmitter<Mm, Mm> for Assembler<'a> {
461    fn mmx_paddq(&mut self, op0: Mm, op1: Mm) {
462        self.emit(
463            MMX_PADDQRR,
464            op0.as_operand(),
465            op1.as_operand(),
466            &NOREG,
467            &NOREG,
468        );
469    }
470}
471
472impl<'a> MmxPaddqEmitter<Mm, Mem> for Assembler<'a> {
473    fn mmx_paddq(&mut self, op0: Mm, op1: Mem) {
474        self.emit(
475            MMX_PADDQRM,
476            op0.as_operand(),
477            op1.as_operand(),
478            &NOREG,
479            &NOREG,
480        );
481    }
482}
483
484/// `MMX_PADDSB`.
485///
486/// Supported operand variants:
487///
488/// ```text
489/// +---+----------+
490/// | # | Operands |
491/// +---+----------+
492/// | 1 | Mm, Mem  |
493/// | 2 | Mm, Mm   |
494/// +---+----------+
495/// ```
496pub trait MmxPaddsbEmitter<A, B> {
497    fn mmx_paddsb(&mut self, op0: A, op1: B);
498}
499
500impl<'a> MmxPaddsbEmitter<Mm, Mm> for Assembler<'a> {
501    fn mmx_paddsb(&mut self, op0: Mm, op1: Mm) {
502        self.emit(
503            MMX_PADDSBRR,
504            op0.as_operand(),
505            op1.as_operand(),
506            &NOREG,
507            &NOREG,
508        );
509    }
510}
511
512impl<'a> MmxPaddsbEmitter<Mm, Mem> for Assembler<'a> {
513    fn mmx_paddsb(&mut self, op0: Mm, op1: Mem) {
514        self.emit(
515            MMX_PADDSBRM,
516            op0.as_operand(),
517            op1.as_operand(),
518            &NOREG,
519            &NOREG,
520        );
521    }
522}
523
524/// `MMX_PADDSW`.
525///
526/// Supported operand variants:
527///
528/// ```text
529/// +---+----------+
530/// | # | Operands |
531/// +---+----------+
532/// | 1 | Mm, Mem  |
533/// | 2 | Mm, Mm   |
534/// +---+----------+
535/// ```
536pub trait MmxPaddswEmitter<A, B> {
537    fn mmx_paddsw(&mut self, op0: A, op1: B);
538}
539
540impl<'a> MmxPaddswEmitter<Mm, Mm> for Assembler<'a> {
541    fn mmx_paddsw(&mut self, op0: Mm, op1: Mm) {
542        self.emit(
543            MMX_PADDSWRR,
544            op0.as_operand(),
545            op1.as_operand(),
546            &NOREG,
547            &NOREG,
548        );
549    }
550}
551
552impl<'a> MmxPaddswEmitter<Mm, Mem> for Assembler<'a> {
553    fn mmx_paddsw(&mut self, op0: Mm, op1: Mem) {
554        self.emit(
555            MMX_PADDSWRM,
556            op0.as_operand(),
557            op1.as_operand(),
558            &NOREG,
559            &NOREG,
560        );
561    }
562}
563
564/// `MMX_PADDUSB`.
565///
566/// Supported operand variants:
567///
568/// ```text
569/// +---+----------+
570/// | # | Operands |
571/// +---+----------+
572/// | 1 | Mm, Mem  |
573/// | 2 | Mm, Mm   |
574/// +---+----------+
575/// ```
576pub trait MmxPaddusbEmitter<A, B> {
577    fn mmx_paddusb(&mut self, op0: A, op1: B);
578}
579
580impl<'a> MmxPaddusbEmitter<Mm, Mm> for Assembler<'a> {
581    fn mmx_paddusb(&mut self, op0: Mm, op1: Mm) {
582        self.emit(
583            MMX_PADDUSBRR,
584            op0.as_operand(),
585            op1.as_operand(),
586            &NOREG,
587            &NOREG,
588        );
589    }
590}
591
592impl<'a> MmxPaddusbEmitter<Mm, Mem> for Assembler<'a> {
593    fn mmx_paddusb(&mut self, op0: Mm, op1: Mem) {
594        self.emit(
595            MMX_PADDUSBRM,
596            op0.as_operand(),
597            op1.as_operand(),
598            &NOREG,
599            &NOREG,
600        );
601    }
602}
603
604/// `MMX_PADDUSW`.
605///
606/// Supported operand variants:
607///
608/// ```text
609/// +---+----------+
610/// | # | Operands |
611/// +---+----------+
612/// | 1 | Mm, Mem  |
613/// | 2 | Mm, Mm   |
614/// +---+----------+
615/// ```
616pub trait MmxPadduswEmitter<A, B> {
617    fn mmx_paddusw(&mut self, op0: A, op1: B);
618}
619
620impl<'a> MmxPadduswEmitter<Mm, Mm> for Assembler<'a> {
621    fn mmx_paddusw(&mut self, op0: Mm, op1: Mm) {
622        self.emit(
623            MMX_PADDUSWRR,
624            op0.as_operand(),
625            op1.as_operand(),
626            &NOREG,
627            &NOREG,
628        );
629    }
630}
631
632impl<'a> MmxPadduswEmitter<Mm, Mem> for Assembler<'a> {
633    fn mmx_paddusw(&mut self, op0: Mm, op1: Mem) {
634        self.emit(
635            MMX_PADDUSWRM,
636            op0.as_operand(),
637            op1.as_operand(),
638            &NOREG,
639            &NOREG,
640        );
641    }
642}
643
644/// `MMX_PADDW`.
645///
646/// Supported operand variants:
647///
648/// ```text
649/// +---+----------+
650/// | # | Operands |
651/// +---+----------+
652/// | 1 | Mm, Mem  |
653/// | 2 | Mm, Mm   |
654/// +---+----------+
655/// ```
656pub trait MmxPaddwEmitter<A, B> {
657    fn mmx_paddw(&mut self, op0: A, op1: B);
658}
659
660impl<'a> MmxPaddwEmitter<Mm, Mm> for Assembler<'a> {
661    fn mmx_paddw(&mut self, op0: Mm, op1: Mm) {
662        self.emit(
663            MMX_PADDWRR,
664            op0.as_operand(),
665            op1.as_operand(),
666            &NOREG,
667            &NOREG,
668        );
669    }
670}
671
672impl<'a> MmxPaddwEmitter<Mm, Mem> for Assembler<'a> {
673    fn mmx_paddw(&mut self, op0: Mm, op1: Mem) {
674        self.emit(
675            MMX_PADDWRM,
676            op0.as_operand(),
677            op1.as_operand(),
678            &NOREG,
679            &NOREG,
680        );
681    }
682}
683
684/// `MMX_PAND`.
685///
686/// Supported operand variants:
687///
688/// ```text
689/// +---+----------+
690/// | # | Operands |
691/// +---+----------+
692/// | 1 | Mm, Mem  |
693/// | 2 | Mm, Mm   |
694/// +---+----------+
695/// ```
696pub trait MmxPandEmitter<A, B> {
697    fn mmx_pand(&mut self, op0: A, op1: B);
698}
699
700impl<'a> MmxPandEmitter<Mm, Mm> for Assembler<'a> {
701    fn mmx_pand(&mut self, op0: Mm, op1: Mm) {
702        self.emit(
703            MMX_PANDRR,
704            op0.as_operand(),
705            op1.as_operand(),
706            &NOREG,
707            &NOREG,
708        );
709    }
710}
711
712impl<'a> MmxPandEmitter<Mm, Mem> for Assembler<'a> {
713    fn mmx_pand(&mut self, op0: Mm, op1: Mem) {
714        self.emit(
715            MMX_PANDRM,
716            op0.as_operand(),
717            op1.as_operand(),
718            &NOREG,
719            &NOREG,
720        );
721    }
722}
723
724/// `MMX_PANDN`.
725///
726/// Supported operand variants:
727///
728/// ```text
729/// +---+----------+
730/// | # | Operands |
731/// +---+----------+
732/// | 1 | Mm, Mem  |
733/// | 2 | Mm, Mm   |
734/// +---+----------+
735/// ```
736pub trait MmxPandnEmitter<A, B> {
737    fn mmx_pandn(&mut self, op0: A, op1: B);
738}
739
740impl<'a> MmxPandnEmitter<Mm, Mm> for Assembler<'a> {
741    fn mmx_pandn(&mut self, op0: Mm, op1: Mm) {
742        self.emit(
743            MMX_PANDNRR,
744            op0.as_operand(),
745            op1.as_operand(),
746            &NOREG,
747            &NOREG,
748        );
749    }
750}
751
752impl<'a> MmxPandnEmitter<Mm, Mem> for Assembler<'a> {
753    fn mmx_pandn(&mut self, op0: Mm, op1: Mem) {
754        self.emit(
755            MMX_PANDNRM,
756            op0.as_operand(),
757            op1.as_operand(),
758            &NOREG,
759            &NOREG,
760        );
761    }
762}
763
764/// `MMX_PCMPEQB`.
765///
766/// Supported operand variants:
767///
768/// ```text
769/// +---+----------+
770/// | # | Operands |
771/// +---+----------+
772/// | 1 | Mm, Mem  |
773/// | 2 | Mm, Mm   |
774/// +---+----------+
775/// ```
776pub trait MmxPcmpeqbEmitter<A, B> {
777    fn mmx_pcmpeqb(&mut self, op0: A, op1: B);
778}
779
780impl<'a> MmxPcmpeqbEmitter<Mm, Mm> for Assembler<'a> {
781    fn mmx_pcmpeqb(&mut self, op0: Mm, op1: Mm) {
782        self.emit(
783            MMX_PCMPEQBRR,
784            op0.as_operand(),
785            op1.as_operand(),
786            &NOREG,
787            &NOREG,
788        );
789    }
790}
791
792impl<'a> MmxPcmpeqbEmitter<Mm, Mem> for Assembler<'a> {
793    fn mmx_pcmpeqb(&mut self, op0: Mm, op1: Mem) {
794        self.emit(
795            MMX_PCMPEQBRM,
796            op0.as_operand(),
797            op1.as_operand(),
798            &NOREG,
799            &NOREG,
800        );
801    }
802}
803
804/// `MMX_PCMPEQD`.
805///
806/// Supported operand variants:
807///
808/// ```text
809/// +---+----------+
810/// | # | Operands |
811/// +---+----------+
812/// | 1 | Mm, Mem  |
813/// | 2 | Mm, Mm   |
814/// +---+----------+
815/// ```
816pub trait MmxPcmpeqdEmitter<A, B> {
817    fn mmx_pcmpeqd(&mut self, op0: A, op1: B);
818}
819
820impl<'a> MmxPcmpeqdEmitter<Mm, Mm> for Assembler<'a> {
821    fn mmx_pcmpeqd(&mut self, op0: Mm, op1: Mm) {
822        self.emit(
823            MMX_PCMPEQDRR,
824            op0.as_operand(),
825            op1.as_operand(),
826            &NOREG,
827            &NOREG,
828        );
829    }
830}
831
832impl<'a> MmxPcmpeqdEmitter<Mm, Mem> for Assembler<'a> {
833    fn mmx_pcmpeqd(&mut self, op0: Mm, op1: Mem) {
834        self.emit(
835            MMX_PCMPEQDRM,
836            op0.as_operand(),
837            op1.as_operand(),
838            &NOREG,
839            &NOREG,
840        );
841    }
842}
843
844/// `MMX_PCMPEQW`.
845///
846/// Supported operand variants:
847///
848/// ```text
849/// +---+----------+
850/// | # | Operands |
851/// +---+----------+
852/// | 1 | Mm, Mem  |
853/// | 2 | Mm, Mm   |
854/// +---+----------+
855/// ```
856pub trait MmxPcmpeqwEmitter<A, B> {
857    fn mmx_pcmpeqw(&mut self, op0: A, op1: B);
858}
859
860impl<'a> MmxPcmpeqwEmitter<Mm, Mm> for Assembler<'a> {
861    fn mmx_pcmpeqw(&mut self, op0: Mm, op1: Mm) {
862        self.emit(
863            MMX_PCMPEQWRR,
864            op0.as_operand(),
865            op1.as_operand(),
866            &NOREG,
867            &NOREG,
868        );
869    }
870}
871
872impl<'a> MmxPcmpeqwEmitter<Mm, Mem> for Assembler<'a> {
873    fn mmx_pcmpeqw(&mut self, op0: Mm, op1: Mem) {
874        self.emit(
875            MMX_PCMPEQWRM,
876            op0.as_operand(),
877            op1.as_operand(),
878            &NOREG,
879            &NOREG,
880        );
881    }
882}
883
884/// `MMX_PCMPGTB`.
885///
886/// Supported operand variants:
887///
888/// ```text
889/// +---+----------+
890/// | # | Operands |
891/// +---+----------+
892/// | 1 | Mm, Mem  |
893/// | 2 | Mm, Mm   |
894/// +---+----------+
895/// ```
896pub trait MmxPcmpgtbEmitter<A, B> {
897    fn mmx_pcmpgtb(&mut self, op0: A, op1: B);
898}
899
900impl<'a> MmxPcmpgtbEmitter<Mm, Mm> for Assembler<'a> {
901    fn mmx_pcmpgtb(&mut self, op0: Mm, op1: Mm) {
902        self.emit(
903            MMX_PCMPGTBRR,
904            op0.as_operand(),
905            op1.as_operand(),
906            &NOREG,
907            &NOREG,
908        );
909    }
910}
911
912impl<'a> MmxPcmpgtbEmitter<Mm, Mem> for Assembler<'a> {
913    fn mmx_pcmpgtb(&mut self, op0: Mm, op1: Mem) {
914        self.emit(
915            MMX_PCMPGTBRM,
916            op0.as_operand(),
917            op1.as_operand(),
918            &NOREG,
919            &NOREG,
920        );
921    }
922}
923
924/// `MMX_PCMPGTD`.
925///
926/// Supported operand variants:
927///
928/// ```text
929/// +---+----------+
930/// | # | Operands |
931/// +---+----------+
932/// | 1 | Mm, Mem  |
933/// | 2 | Mm, Mm   |
934/// +---+----------+
935/// ```
936pub trait MmxPcmpgtdEmitter<A, B> {
937    fn mmx_pcmpgtd(&mut self, op0: A, op1: B);
938}
939
940impl<'a> MmxPcmpgtdEmitter<Mm, Mm> for Assembler<'a> {
941    fn mmx_pcmpgtd(&mut self, op0: Mm, op1: Mm) {
942        self.emit(
943            MMX_PCMPGTDRR,
944            op0.as_operand(),
945            op1.as_operand(),
946            &NOREG,
947            &NOREG,
948        );
949    }
950}
951
952impl<'a> MmxPcmpgtdEmitter<Mm, Mem> for Assembler<'a> {
953    fn mmx_pcmpgtd(&mut self, op0: Mm, op1: Mem) {
954        self.emit(
955            MMX_PCMPGTDRM,
956            op0.as_operand(),
957            op1.as_operand(),
958            &NOREG,
959            &NOREG,
960        );
961    }
962}
963
964/// `MMX_PCMPGTW`.
965///
966/// Supported operand variants:
967///
968/// ```text
969/// +---+----------+
970/// | # | Operands |
971/// +---+----------+
972/// | 1 | Mm, Mem  |
973/// | 2 | Mm, Mm   |
974/// +---+----------+
975/// ```
976pub trait MmxPcmpgtwEmitter<A, B> {
977    fn mmx_pcmpgtw(&mut self, op0: A, op1: B);
978}
979
980impl<'a> MmxPcmpgtwEmitter<Mm, Mm> for Assembler<'a> {
981    fn mmx_pcmpgtw(&mut self, op0: Mm, op1: Mm) {
982        self.emit(
983            MMX_PCMPGTWRR,
984            op0.as_operand(),
985            op1.as_operand(),
986            &NOREG,
987            &NOREG,
988        );
989    }
990}
991
992impl<'a> MmxPcmpgtwEmitter<Mm, Mem> for Assembler<'a> {
993    fn mmx_pcmpgtw(&mut self, op0: Mm, op1: Mem) {
994        self.emit(
995            MMX_PCMPGTWRM,
996            op0.as_operand(),
997            op1.as_operand(),
998            &NOREG,
999            &NOREG,
1000        );
1001    }
1002}
1003
1004/// `MMX_PMADDWD`.
1005///
1006/// Supported operand variants:
1007///
1008/// ```text
1009/// +---+----------+
1010/// | # | Operands |
1011/// +---+----------+
1012/// | 1 | Mm, Mem  |
1013/// | 2 | Mm, Mm   |
1014/// +---+----------+
1015/// ```
1016pub trait MmxPmaddwdEmitter<A, B> {
1017    fn mmx_pmaddwd(&mut self, op0: A, op1: B);
1018}
1019
1020impl<'a> MmxPmaddwdEmitter<Mm, Mm> for Assembler<'a> {
1021    fn mmx_pmaddwd(&mut self, op0: Mm, op1: Mm) {
1022        self.emit(
1023            MMX_PMADDWDRR,
1024            op0.as_operand(),
1025            op1.as_operand(),
1026            &NOREG,
1027            &NOREG,
1028        );
1029    }
1030}
1031
1032impl<'a> MmxPmaddwdEmitter<Mm, Mem> for Assembler<'a> {
1033    fn mmx_pmaddwd(&mut self, op0: Mm, op1: Mem) {
1034        self.emit(
1035            MMX_PMADDWDRM,
1036            op0.as_operand(),
1037            op1.as_operand(),
1038            &NOREG,
1039            &NOREG,
1040        );
1041    }
1042}
1043
1044/// `MMX_PMULHW`.
1045///
1046/// Supported operand variants:
1047///
1048/// ```text
1049/// +---+----------+
1050/// | # | Operands |
1051/// +---+----------+
1052/// | 1 | Mm, Mem  |
1053/// | 2 | Mm, Mm   |
1054/// +---+----------+
1055/// ```
1056pub trait MmxPmulhwEmitter<A, B> {
1057    fn mmx_pmulhw(&mut self, op0: A, op1: B);
1058}
1059
1060impl<'a> MmxPmulhwEmitter<Mm, Mm> for Assembler<'a> {
1061    fn mmx_pmulhw(&mut self, op0: Mm, op1: Mm) {
1062        self.emit(
1063            MMX_PMULHWRR,
1064            op0.as_operand(),
1065            op1.as_operand(),
1066            &NOREG,
1067            &NOREG,
1068        );
1069    }
1070}
1071
1072impl<'a> MmxPmulhwEmitter<Mm, Mem> for Assembler<'a> {
1073    fn mmx_pmulhw(&mut self, op0: Mm, op1: Mem) {
1074        self.emit(
1075            MMX_PMULHWRM,
1076            op0.as_operand(),
1077            op1.as_operand(),
1078            &NOREG,
1079            &NOREG,
1080        );
1081    }
1082}
1083
1084/// `MMX_PMULLW`.
1085///
1086/// Supported operand variants:
1087///
1088/// ```text
1089/// +---+----------+
1090/// | # | Operands |
1091/// +---+----------+
1092/// | 1 | Mm, Mem  |
1093/// | 2 | Mm, Mm   |
1094/// +---+----------+
1095/// ```
1096pub trait MmxPmullwEmitter<A, B> {
1097    fn mmx_pmullw(&mut self, op0: A, op1: B);
1098}
1099
1100impl<'a> MmxPmullwEmitter<Mm, Mm> for Assembler<'a> {
1101    fn mmx_pmullw(&mut self, op0: Mm, op1: Mm) {
1102        self.emit(
1103            MMX_PMULLWRR,
1104            op0.as_operand(),
1105            op1.as_operand(),
1106            &NOREG,
1107            &NOREG,
1108        );
1109    }
1110}
1111
1112impl<'a> MmxPmullwEmitter<Mm, Mem> for Assembler<'a> {
1113    fn mmx_pmullw(&mut self, op0: Mm, op1: Mem) {
1114        self.emit(
1115            MMX_PMULLWRM,
1116            op0.as_operand(),
1117            op1.as_operand(),
1118            &NOREG,
1119            &NOREG,
1120        );
1121    }
1122}
1123
1124/// `MMX_PMULUDQ`.
1125///
1126/// Supported operand variants:
1127///
1128/// ```text
1129/// +---+----------+
1130/// | # | Operands |
1131/// +---+----------+
1132/// | 1 | Mm, Mem  |
1133/// | 2 | Mm, Mm   |
1134/// +---+----------+
1135/// ```
1136pub trait MmxPmuludqEmitter<A, B> {
1137    fn mmx_pmuludq(&mut self, op0: A, op1: B);
1138}
1139
1140impl<'a> MmxPmuludqEmitter<Mm, Mm> for Assembler<'a> {
1141    fn mmx_pmuludq(&mut self, op0: Mm, op1: Mm) {
1142        self.emit(
1143            MMX_PMULUDQRR,
1144            op0.as_operand(),
1145            op1.as_operand(),
1146            &NOREG,
1147            &NOREG,
1148        );
1149    }
1150}
1151
1152impl<'a> MmxPmuludqEmitter<Mm, Mem> for Assembler<'a> {
1153    fn mmx_pmuludq(&mut self, op0: Mm, op1: Mem) {
1154        self.emit(
1155            MMX_PMULUDQRM,
1156            op0.as_operand(),
1157            op1.as_operand(),
1158            &NOREG,
1159            &NOREG,
1160        );
1161    }
1162}
1163
1164/// `MMX_POR`.
1165///
1166/// Supported operand variants:
1167///
1168/// ```text
1169/// +---+----------+
1170/// | # | Operands |
1171/// +---+----------+
1172/// | 1 | Mm, Mem  |
1173/// | 2 | Mm, Mm   |
1174/// +---+----------+
1175/// ```
1176pub trait MmxPorEmitter<A, B> {
1177    fn mmx_por(&mut self, op0: A, op1: B);
1178}
1179
1180impl<'a> MmxPorEmitter<Mm, Mm> for Assembler<'a> {
1181    fn mmx_por(&mut self, op0: Mm, op1: Mm) {
1182        self.emit(
1183            MMX_PORRR,
1184            op0.as_operand(),
1185            op1.as_operand(),
1186            &NOREG,
1187            &NOREG,
1188        );
1189    }
1190}
1191
1192impl<'a> MmxPorEmitter<Mm, Mem> for Assembler<'a> {
1193    fn mmx_por(&mut self, op0: Mm, op1: Mem) {
1194        self.emit(
1195            MMX_PORRM,
1196            op0.as_operand(),
1197            op1.as_operand(),
1198            &NOREG,
1199            &NOREG,
1200        );
1201    }
1202}
1203
1204/// `MMX_PSLLD`.
1205///
1206/// Supported operand variants:
1207///
1208/// ```text
1209/// +---+----------+
1210/// | # | Operands |
1211/// +---+----------+
1212/// | 1 | Mm, Imm  |
1213/// | 2 | Mm, Mem  |
1214/// | 3 | Mm, Mm   |
1215/// +---+----------+
1216/// ```
1217pub trait MmxPslldEmitter<A, B> {
1218    fn mmx_pslld(&mut self, op0: A, op1: B);
1219}
1220
1221impl<'a> MmxPslldEmitter<Mm, Imm> for Assembler<'a> {
1222    fn mmx_pslld(&mut self, op0: Mm, op1: Imm) {
1223        self.emit(
1224            MMX_PSLLDRI,
1225            op0.as_operand(),
1226            op1.as_operand(),
1227            &NOREG,
1228            &NOREG,
1229        );
1230    }
1231}
1232
1233impl<'a> MmxPslldEmitter<Mm, Mm> for Assembler<'a> {
1234    fn mmx_pslld(&mut self, op0: Mm, op1: Mm) {
1235        self.emit(
1236            MMX_PSLLDRR,
1237            op0.as_operand(),
1238            op1.as_operand(),
1239            &NOREG,
1240            &NOREG,
1241        );
1242    }
1243}
1244
1245impl<'a> MmxPslldEmitter<Mm, Mem> for Assembler<'a> {
1246    fn mmx_pslld(&mut self, op0: Mm, op1: Mem) {
1247        self.emit(
1248            MMX_PSLLDRM,
1249            op0.as_operand(),
1250            op1.as_operand(),
1251            &NOREG,
1252            &NOREG,
1253        );
1254    }
1255}
1256
1257/// `MMX_PSLLQ`.
1258///
1259/// Supported operand variants:
1260///
1261/// ```text
1262/// +---+----------+
1263/// | # | Operands |
1264/// +---+----------+
1265/// | 1 | Mm, Imm  |
1266/// | 2 | Mm, Mem  |
1267/// | 3 | Mm, Mm   |
1268/// +---+----------+
1269/// ```
1270pub trait MmxPsllqEmitter<A, B> {
1271    fn mmx_psllq(&mut self, op0: A, op1: B);
1272}
1273
1274impl<'a> MmxPsllqEmitter<Mm, Imm> for Assembler<'a> {
1275    fn mmx_psllq(&mut self, op0: Mm, op1: Imm) {
1276        self.emit(
1277            MMX_PSLLQRI,
1278            op0.as_operand(),
1279            op1.as_operand(),
1280            &NOREG,
1281            &NOREG,
1282        );
1283    }
1284}
1285
1286impl<'a> MmxPsllqEmitter<Mm, Mm> for Assembler<'a> {
1287    fn mmx_psllq(&mut self, op0: Mm, op1: Mm) {
1288        self.emit(
1289            MMX_PSLLQRR,
1290            op0.as_operand(),
1291            op1.as_operand(),
1292            &NOREG,
1293            &NOREG,
1294        );
1295    }
1296}
1297
1298impl<'a> MmxPsllqEmitter<Mm, Mem> for Assembler<'a> {
1299    fn mmx_psllq(&mut self, op0: Mm, op1: Mem) {
1300        self.emit(
1301            MMX_PSLLQRM,
1302            op0.as_operand(),
1303            op1.as_operand(),
1304            &NOREG,
1305            &NOREG,
1306        );
1307    }
1308}
1309
1310/// `MMX_PSLLW`.
1311///
1312/// Supported operand variants:
1313///
1314/// ```text
1315/// +---+----------+
1316/// | # | Operands |
1317/// +---+----------+
1318/// | 1 | Mm, Imm  |
1319/// | 2 | Mm, Mem  |
1320/// | 3 | Mm, Mm   |
1321/// +---+----------+
1322/// ```
1323pub trait MmxPsllwEmitter<A, B> {
1324    fn mmx_psllw(&mut self, op0: A, op1: B);
1325}
1326
1327impl<'a> MmxPsllwEmitter<Mm, Imm> for Assembler<'a> {
1328    fn mmx_psllw(&mut self, op0: Mm, op1: Imm) {
1329        self.emit(
1330            MMX_PSLLWRI,
1331            op0.as_operand(),
1332            op1.as_operand(),
1333            &NOREG,
1334            &NOREG,
1335        );
1336    }
1337}
1338
1339impl<'a> MmxPsllwEmitter<Mm, Mm> for Assembler<'a> {
1340    fn mmx_psllw(&mut self, op0: Mm, op1: Mm) {
1341        self.emit(
1342            MMX_PSLLWRR,
1343            op0.as_operand(),
1344            op1.as_operand(),
1345            &NOREG,
1346            &NOREG,
1347        );
1348    }
1349}
1350
1351impl<'a> MmxPsllwEmitter<Mm, Mem> for Assembler<'a> {
1352    fn mmx_psllw(&mut self, op0: Mm, op1: Mem) {
1353        self.emit(
1354            MMX_PSLLWRM,
1355            op0.as_operand(),
1356            op1.as_operand(),
1357            &NOREG,
1358            &NOREG,
1359        );
1360    }
1361}
1362
1363/// `MMX_PSRAD`.
1364///
1365/// Supported operand variants:
1366///
1367/// ```text
1368/// +---+----------+
1369/// | # | Operands |
1370/// +---+----------+
1371/// | 1 | Mm, Imm  |
1372/// | 2 | Mm, Mem  |
1373/// | 3 | Mm, Mm   |
1374/// +---+----------+
1375/// ```
1376pub trait MmxPsradEmitter<A, B> {
1377    fn mmx_psrad(&mut self, op0: A, op1: B);
1378}
1379
1380impl<'a> MmxPsradEmitter<Mm, Imm> for Assembler<'a> {
1381    fn mmx_psrad(&mut self, op0: Mm, op1: Imm) {
1382        self.emit(
1383            MMX_PSRADRI,
1384            op0.as_operand(),
1385            op1.as_operand(),
1386            &NOREG,
1387            &NOREG,
1388        );
1389    }
1390}
1391
1392impl<'a> MmxPsradEmitter<Mm, Mm> for Assembler<'a> {
1393    fn mmx_psrad(&mut self, op0: Mm, op1: Mm) {
1394        self.emit(
1395            MMX_PSRADRR,
1396            op0.as_operand(),
1397            op1.as_operand(),
1398            &NOREG,
1399            &NOREG,
1400        );
1401    }
1402}
1403
1404impl<'a> MmxPsradEmitter<Mm, Mem> for Assembler<'a> {
1405    fn mmx_psrad(&mut self, op0: Mm, op1: Mem) {
1406        self.emit(
1407            MMX_PSRADRM,
1408            op0.as_operand(),
1409            op1.as_operand(),
1410            &NOREG,
1411            &NOREG,
1412        );
1413    }
1414}
1415
1416/// `MMX_PSRAW`.
1417///
1418/// Supported operand variants:
1419///
1420/// ```text
1421/// +---+----------+
1422/// | # | Operands |
1423/// +---+----------+
1424/// | 1 | Mm, Imm  |
1425/// | 2 | Mm, Mem  |
1426/// | 3 | Mm, Mm   |
1427/// +---+----------+
1428/// ```
1429pub trait MmxPsrawEmitter<A, B> {
1430    fn mmx_psraw(&mut self, op0: A, op1: B);
1431}
1432
1433impl<'a> MmxPsrawEmitter<Mm, Imm> for Assembler<'a> {
1434    fn mmx_psraw(&mut self, op0: Mm, op1: Imm) {
1435        self.emit(
1436            MMX_PSRAWRI,
1437            op0.as_operand(),
1438            op1.as_operand(),
1439            &NOREG,
1440            &NOREG,
1441        );
1442    }
1443}
1444
1445impl<'a> MmxPsrawEmitter<Mm, Mm> for Assembler<'a> {
1446    fn mmx_psraw(&mut self, op0: Mm, op1: Mm) {
1447        self.emit(
1448            MMX_PSRAWRR,
1449            op0.as_operand(),
1450            op1.as_operand(),
1451            &NOREG,
1452            &NOREG,
1453        );
1454    }
1455}
1456
1457impl<'a> MmxPsrawEmitter<Mm, Mem> for Assembler<'a> {
1458    fn mmx_psraw(&mut self, op0: Mm, op1: Mem) {
1459        self.emit(
1460            MMX_PSRAWRM,
1461            op0.as_operand(),
1462            op1.as_operand(),
1463            &NOREG,
1464            &NOREG,
1465        );
1466    }
1467}
1468
1469/// `MMX_PSRLD`.
1470///
1471/// Supported operand variants:
1472///
1473/// ```text
1474/// +---+----------+
1475/// | # | Operands |
1476/// +---+----------+
1477/// | 1 | Mm, Imm  |
1478/// | 2 | Mm, Mem  |
1479/// | 3 | Mm, Mm   |
1480/// +---+----------+
1481/// ```
1482pub trait MmxPsrldEmitter<A, B> {
1483    fn mmx_psrld(&mut self, op0: A, op1: B);
1484}
1485
1486impl<'a> MmxPsrldEmitter<Mm, Imm> for Assembler<'a> {
1487    fn mmx_psrld(&mut self, op0: Mm, op1: Imm) {
1488        self.emit(
1489            MMX_PSRLDRI,
1490            op0.as_operand(),
1491            op1.as_operand(),
1492            &NOREG,
1493            &NOREG,
1494        );
1495    }
1496}
1497
1498impl<'a> MmxPsrldEmitter<Mm, Mm> for Assembler<'a> {
1499    fn mmx_psrld(&mut self, op0: Mm, op1: Mm) {
1500        self.emit(
1501            MMX_PSRLDRR,
1502            op0.as_operand(),
1503            op1.as_operand(),
1504            &NOREG,
1505            &NOREG,
1506        );
1507    }
1508}
1509
1510impl<'a> MmxPsrldEmitter<Mm, Mem> for Assembler<'a> {
1511    fn mmx_psrld(&mut self, op0: Mm, op1: Mem) {
1512        self.emit(
1513            MMX_PSRLDRM,
1514            op0.as_operand(),
1515            op1.as_operand(),
1516            &NOREG,
1517            &NOREG,
1518        );
1519    }
1520}
1521
1522/// `MMX_PSRLQ`.
1523///
1524/// Supported operand variants:
1525///
1526/// ```text
1527/// +---+----------+
1528/// | # | Operands |
1529/// +---+----------+
1530/// | 1 | Mm, Imm  |
1531/// | 2 | Mm, Mem  |
1532/// | 3 | Mm, Mm   |
1533/// +---+----------+
1534/// ```
1535pub trait MmxPsrlqEmitter<A, B> {
1536    fn mmx_psrlq(&mut self, op0: A, op1: B);
1537}
1538
1539impl<'a> MmxPsrlqEmitter<Mm, Imm> for Assembler<'a> {
1540    fn mmx_psrlq(&mut self, op0: Mm, op1: Imm) {
1541        self.emit(
1542            MMX_PSRLQRI,
1543            op0.as_operand(),
1544            op1.as_operand(),
1545            &NOREG,
1546            &NOREG,
1547        );
1548    }
1549}
1550
1551impl<'a> MmxPsrlqEmitter<Mm, Mm> for Assembler<'a> {
1552    fn mmx_psrlq(&mut self, op0: Mm, op1: Mm) {
1553        self.emit(
1554            MMX_PSRLQRR,
1555            op0.as_operand(),
1556            op1.as_operand(),
1557            &NOREG,
1558            &NOREG,
1559        );
1560    }
1561}
1562
1563impl<'a> MmxPsrlqEmitter<Mm, Mem> for Assembler<'a> {
1564    fn mmx_psrlq(&mut self, op0: Mm, op1: Mem) {
1565        self.emit(
1566            MMX_PSRLQRM,
1567            op0.as_operand(),
1568            op1.as_operand(),
1569            &NOREG,
1570            &NOREG,
1571        );
1572    }
1573}
1574
1575/// `MMX_PSRLW`.
1576///
1577/// Supported operand variants:
1578///
1579/// ```text
1580/// +---+----------+
1581/// | # | Operands |
1582/// +---+----------+
1583/// | 1 | Mm, Imm  |
1584/// | 2 | Mm, Mem  |
1585/// | 3 | Mm, Mm   |
1586/// +---+----------+
1587/// ```
1588pub trait MmxPsrlwEmitter<A, B> {
1589    fn mmx_psrlw(&mut self, op0: A, op1: B);
1590}
1591
1592impl<'a> MmxPsrlwEmitter<Mm, Imm> for Assembler<'a> {
1593    fn mmx_psrlw(&mut self, op0: Mm, op1: Imm) {
1594        self.emit(
1595            MMX_PSRLWRI,
1596            op0.as_operand(),
1597            op1.as_operand(),
1598            &NOREG,
1599            &NOREG,
1600        );
1601    }
1602}
1603
1604impl<'a> MmxPsrlwEmitter<Mm, Mm> for Assembler<'a> {
1605    fn mmx_psrlw(&mut self, op0: Mm, op1: Mm) {
1606        self.emit(
1607            MMX_PSRLWRR,
1608            op0.as_operand(),
1609            op1.as_operand(),
1610            &NOREG,
1611            &NOREG,
1612        );
1613    }
1614}
1615
1616impl<'a> MmxPsrlwEmitter<Mm, Mem> for Assembler<'a> {
1617    fn mmx_psrlw(&mut self, op0: Mm, op1: Mem) {
1618        self.emit(
1619            MMX_PSRLWRM,
1620            op0.as_operand(),
1621            op1.as_operand(),
1622            &NOREG,
1623            &NOREG,
1624        );
1625    }
1626}
1627
1628/// `MMX_PSUBB`.
1629///
1630/// Supported operand variants:
1631///
1632/// ```text
1633/// +---+----------+
1634/// | # | Operands |
1635/// +---+----------+
1636/// | 1 | Mm, Mem  |
1637/// | 2 | Mm, Mm   |
1638/// +---+----------+
1639/// ```
1640pub trait MmxPsubbEmitter<A, B> {
1641    fn mmx_psubb(&mut self, op0: A, op1: B);
1642}
1643
1644impl<'a> MmxPsubbEmitter<Mm, Mm> for Assembler<'a> {
1645    fn mmx_psubb(&mut self, op0: Mm, op1: Mm) {
1646        self.emit(
1647            MMX_PSUBBRR,
1648            op0.as_operand(),
1649            op1.as_operand(),
1650            &NOREG,
1651            &NOREG,
1652        );
1653    }
1654}
1655
1656impl<'a> MmxPsubbEmitter<Mm, Mem> for Assembler<'a> {
1657    fn mmx_psubb(&mut self, op0: Mm, op1: Mem) {
1658        self.emit(
1659            MMX_PSUBBRM,
1660            op0.as_operand(),
1661            op1.as_operand(),
1662            &NOREG,
1663            &NOREG,
1664        );
1665    }
1666}
1667
1668/// `MMX_PSUBD`.
1669///
1670/// Supported operand variants:
1671///
1672/// ```text
1673/// +---+----------+
1674/// | # | Operands |
1675/// +---+----------+
1676/// | 1 | Mm, Mem  |
1677/// | 2 | Mm, Mm   |
1678/// +---+----------+
1679/// ```
1680pub trait MmxPsubdEmitter<A, B> {
1681    fn mmx_psubd(&mut self, op0: A, op1: B);
1682}
1683
1684impl<'a> MmxPsubdEmitter<Mm, Mm> for Assembler<'a> {
1685    fn mmx_psubd(&mut self, op0: Mm, op1: Mm) {
1686        self.emit(
1687            MMX_PSUBDRR,
1688            op0.as_operand(),
1689            op1.as_operand(),
1690            &NOREG,
1691            &NOREG,
1692        );
1693    }
1694}
1695
1696impl<'a> MmxPsubdEmitter<Mm, Mem> for Assembler<'a> {
1697    fn mmx_psubd(&mut self, op0: Mm, op1: Mem) {
1698        self.emit(
1699            MMX_PSUBDRM,
1700            op0.as_operand(),
1701            op1.as_operand(),
1702            &NOREG,
1703            &NOREG,
1704        );
1705    }
1706}
1707
1708/// `MMX_PSUBQ`.
1709///
1710/// Supported operand variants:
1711///
1712/// ```text
1713/// +---+----------+
1714/// | # | Operands |
1715/// +---+----------+
1716/// | 1 | Mm, Mem  |
1717/// | 2 | Mm, Mm   |
1718/// +---+----------+
1719/// ```
1720pub trait MmxPsubqEmitter<A, B> {
1721    fn mmx_psubq(&mut self, op0: A, op1: B);
1722}
1723
1724impl<'a> MmxPsubqEmitter<Mm, Mm> for Assembler<'a> {
1725    fn mmx_psubq(&mut self, op0: Mm, op1: Mm) {
1726        self.emit(
1727            MMX_PSUBQRR,
1728            op0.as_operand(),
1729            op1.as_operand(),
1730            &NOREG,
1731            &NOREG,
1732        );
1733    }
1734}
1735
1736impl<'a> MmxPsubqEmitter<Mm, Mem> for Assembler<'a> {
1737    fn mmx_psubq(&mut self, op0: Mm, op1: Mem) {
1738        self.emit(
1739            MMX_PSUBQRM,
1740            op0.as_operand(),
1741            op1.as_operand(),
1742            &NOREG,
1743            &NOREG,
1744        );
1745    }
1746}
1747
1748/// `MMX_PSUBSB`.
1749///
1750/// Supported operand variants:
1751///
1752/// ```text
1753/// +---+----------+
1754/// | # | Operands |
1755/// +---+----------+
1756/// | 1 | Mm, Mem  |
1757/// | 2 | Mm, Mm   |
1758/// +---+----------+
1759/// ```
1760pub trait MmxPsubsbEmitter<A, B> {
1761    fn mmx_psubsb(&mut self, op0: A, op1: B);
1762}
1763
1764impl<'a> MmxPsubsbEmitter<Mm, Mm> for Assembler<'a> {
1765    fn mmx_psubsb(&mut self, op0: Mm, op1: Mm) {
1766        self.emit(
1767            MMX_PSUBSBRR,
1768            op0.as_operand(),
1769            op1.as_operand(),
1770            &NOREG,
1771            &NOREG,
1772        );
1773    }
1774}
1775
1776impl<'a> MmxPsubsbEmitter<Mm, Mem> for Assembler<'a> {
1777    fn mmx_psubsb(&mut self, op0: Mm, op1: Mem) {
1778        self.emit(
1779            MMX_PSUBSBRM,
1780            op0.as_operand(),
1781            op1.as_operand(),
1782            &NOREG,
1783            &NOREG,
1784        );
1785    }
1786}
1787
1788/// `MMX_PSUBSW`.
1789///
1790/// Supported operand variants:
1791///
1792/// ```text
1793/// +---+----------+
1794/// | # | Operands |
1795/// +---+----------+
1796/// | 1 | Mm, Mem  |
1797/// | 2 | Mm, Mm   |
1798/// +---+----------+
1799/// ```
1800pub trait MmxPsubswEmitter<A, B> {
1801    fn mmx_psubsw(&mut self, op0: A, op1: B);
1802}
1803
1804impl<'a> MmxPsubswEmitter<Mm, Mm> for Assembler<'a> {
1805    fn mmx_psubsw(&mut self, op0: Mm, op1: Mm) {
1806        self.emit(
1807            MMX_PSUBSWRR,
1808            op0.as_operand(),
1809            op1.as_operand(),
1810            &NOREG,
1811            &NOREG,
1812        );
1813    }
1814}
1815
1816impl<'a> MmxPsubswEmitter<Mm, Mem> for Assembler<'a> {
1817    fn mmx_psubsw(&mut self, op0: Mm, op1: Mem) {
1818        self.emit(
1819            MMX_PSUBSWRM,
1820            op0.as_operand(),
1821            op1.as_operand(),
1822            &NOREG,
1823            &NOREG,
1824        );
1825    }
1826}
1827
1828/// `MMX_PSUBUSB`.
1829///
1830/// Supported operand variants:
1831///
1832/// ```text
1833/// +---+----------+
1834/// | # | Operands |
1835/// +---+----------+
1836/// | 1 | Mm, Mem  |
1837/// | 2 | Mm, Mm   |
1838/// +---+----------+
1839/// ```
1840pub trait MmxPsubusbEmitter<A, B> {
1841    fn mmx_psubusb(&mut self, op0: A, op1: B);
1842}
1843
1844impl<'a> MmxPsubusbEmitter<Mm, Mm> for Assembler<'a> {
1845    fn mmx_psubusb(&mut self, op0: Mm, op1: Mm) {
1846        self.emit(
1847            MMX_PSUBUSBRR,
1848            op0.as_operand(),
1849            op1.as_operand(),
1850            &NOREG,
1851            &NOREG,
1852        );
1853    }
1854}
1855
1856impl<'a> MmxPsubusbEmitter<Mm, Mem> for Assembler<'a> {
1857    fn mmx_psubusb(&mut self, op0: Mm, op1: Mem) {
1858        self.emit(
1859            MMX_PSUBUSBRM,
1860            op0.as_operand(),
1861            op1.as_operand(),
1862            &NOREG,
1863            &NOREG,
1864        );
1865    }
1866}
1867
1868/// `MMX_PSUBUSW`.
1869///
1870/// Supported operand variants:
1871///
1872/// ```text
1873/// +---+----------+
1874/// | # | Operands |
1875/// +---+----------+
1876/// | 1 | Mm, Mem  |
1877/// | 2 | Mm, Mm   |
1878/// +---+----------+
1879/// ```
1880pub trait MmxPsubuswEmitter<A, B> {
1881    fn mmx_psubusw(&mut self, op0: A, op1: B);
1882}
1883
1884impl<'a> MmxPsubuswEmitter<Mm, Mm> for Assembler<'a> {
1885    fn mmx_psubusw(&mut self, op0: Mm, op1: Mm) {
1886        self.emit(
1887            MMX_PSUBUSWRR,
1888            op0.as_operand(),
1889            op1.as_operand(),
1890            &NOREG,
1891            &NOREG,
1892        );
1893    }
1894}
1895
1896impl<'a> MmxPsubuswEmitter<Mm, Mem> for Assembler<'a> {
1897    fn mmx_psubusw(&mut self, op0: Mm, op1: Mem) {
1898        self.emit(
1899            MMX_PSUBUSWRM,
1900            op0.as_operand(),
1901            op1.as_operand(),
1902            &NOREG,
1903            &NOREG,
1904        );
1905    }
1906}
1907
1908/// `MMX_PSUBW`.
1909///
1910/// Supported operand variants:
1911///
1912/// ```text
1913/// +---+----------+
1914/// | # | Operands |
1915/// +---+----------+
1916/// | 1 | Mm, Mem  |
1917/// | 2 | Mm, Mm   |
1918/// +---+----------+
1919/// ```
1920pub trait MmxPsubwEmitter<A, B> {
1921    fn mmx_psubw(&mut self, op0: A, op1: B);
1922}
1923
1924impl<'a> MmxPsubwEmitter<Mm, Mm> for Assembler<'a> {
1925    fn mmx_psubw(&mut self, op0: Mm, op1: Mm) {
1926        self.emit(
1927            MMX_PSUBWRR,
1928            op0.as_operand(),
1929            op1.as_operand(),
1930            &NOREG,
1931            &NOREG,
1932        );
1933    }
1934}
1935
1936impl<'a> MmxPsubwEmitter<Mm, Mem> for Assembler<'a> {
1937    fn mmx_psubw(&mut self, op0: Mm, op1: Mem) {
1938        self.emit(
1939            MMX_PSUBWRM,
1940            op0.as_operand(),
1941            op1.as_operand(),
1942            &NOREG,
1943            &NOREG,
1944        );
1945    }
1946}
1947
1948/// `MMX_PUNPCKHBW`.
1949///
1950/// Supported operand variants:
1951///
1952/// ```text
1953/// +---+----------+
1954/// | # | Operands |
1955/// +---+----------+
1956/// | 1 | Mm, Mem  |
1957/// | 2 | Mm, Mm   |
1958/// +---+----------+
1959/// ```
1960pub trait MmxPunpckhbwEmitter<A, B> {
1961    fn mmx_punpckhbw(&mut self, op0: A, op1: B);
1962}
1963
1964impl<'a> MmxPunpckhbwEmitter<Mm, Mm> for Assembler<'a> {
1965    fn mmx_punpckhbw(&mut self, op0: Mm, op1: Mm) {
1966        self.emit(
1967            MMX_PUNPCKHBWRR,
1968            op0.as_operand(),
1969            op1.as_operand(),
1970            &NOREG,
1971            &NOREG,
1972        );
1973    }
1974}
1975
1976impl<'a> MmxPunpckhbwEmitter<Mm, Mem> for Assembler<'a> {
1977    fn mmx_punpckhbw(&mut self, op0: Mm, op1: Mem) {
1978        self.emit(
1979            MMX_PUNPCKHBWRM,
1980            op0.as_operand(),
1981            op1.as_operand(),
1982            &NOREG,
1983            &NOREG,
1984        );
1985    }
1986}
1987
1988/// `MMX_PUNPCKHDQ`.
1989///
1990/// Supported operand variants:
1991///
1992/// ```text
1993/// +---+----------+
1994/// | # | Operands |
1995/// +---+----------+
1996/// | 1 | Mm, Mem  |
1997/// | 2 | Mm, Mm   |
1998/// +---+----------+
1999/// ```
2000pub trait MmxPunpckhdqEmitter<A, B> {
2001    fn mmx_punpckhdq(&mut self, op0: A, op1: B);
2002}
2003
2004impl<'a> MmxPunpckhdqEmitter<Mm, Mm> for Assembler<'a> {
2005    fn mmx_punpckhdq(&mut self, op0: Mm, op1: Mm) {
2006        self.emit(
2007            MMX_PUNPCKHDQRR,
2008            op0.as_operand(),
2009            op1.as_operand(),
2010            &NOREG,
2011            &NOREG,
2012        );
2013    }
2014}
2015
2016impl<'a> MmxPunpckhdqEmitter<Mm, Mem> for Assembler<'a> {
2017    fn mmx_punpckhdq(&mut self, op0: Mm, op1: Mem) {
2018        self.emit(
2019            MMX_PUNPCKHDQRM,
2020            op0.as_operand(),
2021            op1.as_operand(),
2022            &NOREG,
2023            &NOREG,
2024        );
2025    }
2026}
2027
2028/// `MMX_PUNPCKHWD`.
2029///
2030/// Supported operand variants:
2031///
2032/// ```text
2033/// +---+----------+
2034/// | # | Operands |
2035/// +---+----------+
2036/// | 1 | Mm, Mem  |
2037/// | 2 | Mm, Mm   |
2038/// +---+----------+
2039/// ```
2040pub trait MmxPunpckhwdEmitter<A, B> {
2041    fn mmx_punpckhwd(&mut self, op0: A, op1: B);
2042}
2043
2044impl<'a> MmxPunpckhwdEmitter<Mm, Mm> for Assembler<'a> {
2045    fn mmx_punpckhwd(&mut self, op0: Mm, op1: Mm) {
2046        self.emit(
2047            MMX_PUNPCKHWDRR,
2048            op0.as_operand(),
2049            op1.as_operand(),
2050            &NOREG,
2051            &NOREG,
2052        );
2053    }
2054}
2055
2056impl<'a> MmxPunpckhwdEmitter<Mm, Mem> for Assembler<'a> {
2057    fn mmx_punpckhwd(&mut self, op0: Mm, op1: Mem) {
2058        self.emit(
2059            MMX_PUNPCKHWDRM,
2060            op0.as_operand(),
2061            op1.as_operand(),
2062            &NOREG,
2063            &NOREG,
2064        );
2065    }
2066}
2067
2068/// `MMX_PUNPCKLBW`.
2069///
2070/// Supported operand variants:
2071///
2072/// ```text
2073/// +---+----------+
2074/// | # | Operands |
2075/// +---+----------+
2076/// | 1 | Mm, Mem  |
2077/// | 2 | Mm, Mm   |
2078/// +---+----------+
2079/// ```
2080pub trait MmxPunpcklbwEmitter<A, B> {
2081    fn mmx_punpcklbw(&mut self, op0: A, op1: B);
2082}
2083
2084impl<'a> MmxPunpcklbwEmitter<Mm, Mm> for Assembler<'a> {
2085    fn mmx_punpcklbw(&mut self, op0: Mm, op1: Mm) {
2086        self.emit(
2087            MMX_PUNPCKLBWRR,
2088            op0.as_operand(),
2089            op1.as_operand(),
2090            &NOREG,
2091            &NOREG,
2092        );
2093    }
2094}
2095
2096impl<'a> MmxPunpcklbwEmitter<Mm, Mem> for Assembler<'a> {
2097    fn mmx_punpcklbw(&mut self, op0: Mm, op1: Mem) {
2098        self.emit(
2099            MMX_PUNPCKLBWRM,
2100            op0.as_operand(),
2101            op1.as_operand(),
2102            &NOREG,
2103            &NOREG,
2104        );
2105    }
2106}
2107
2108/// `MMX_PUNPCKLDQ`.
2109///
2110/// Supported operand variants:
2111///
2112/// ```text
2113/// +---+----------+
2114/// | # | Operands |
2115/// +---+----------+
2116/// | 1 | Mm, Mem  |
2117/// | 2 | Mm, Mm   |
2118/// +---+----------+
2119/// ```
2120pub trait MmxPunpckldqEmitter<A, B> {
2121    fn mmx_punpckldq(&mut self, op0: A, op1: B);
2122}
2123
2124impl<'a> MmxPunpckldqEmitter<Mm, Mm> for Assembler<'a> {
2125    fn mmx_punpckldq(&mut self, op0: Mm, op1: Mm) {
2126        self.emit(
2127            MMX_PUNPCKLDQRR,
2128            op0.as_operand(),
2129            op1.as_operand(),
2130            &NOREG,
2131            &NOREG,
2132        );
2133    }
2134}
2135
2136impl<'a> MmxPunpckldqEmitter<Mm, Mem> for Assembler<'a> {
2137    fn mmx_punpckldq(&mut self, op0: Mm, op1: Mem) {
2138        self.emit(
2139            MMX_PUNPCKLDQRM,
2140            op0.as_operand(),
2141            op1.as_operand(),
2142            &NOREG,
2143            &NOREG,
2144        );
2145    }
2146}
2147
2148/// `MMX_PUNPCKLWD`.
2149///
2150/// Supported operand variants:
2151///
2152/// ```text
2153/// +---+----------+
2154/// | # | Operands |
2155/// +---+----------+
2156/// | 1 | Mm, Mem  |
2157/// | 2 | Mm, Mm   |
2158/// +---+----------+
2159/// ```
2160pub trait MmxPunpcklwdEmitter<A, B> {
2161    fn mmx_punpcklwd(&mut self, op0: A, op1: B);
2162}
2163
2164impl<'a> MmxPunpcklwdEmitter<Mm, Mm> for Assembler<'a> {
2165    fn mmx_punpcklwd(&mut self, op0: Mm, op1: Mm) {
2166        self.emit(
2167            MMX_PUNPCKLWDRR,
2168            op0.as_operand(),
2169            op1.as_operand(),
2170            &NOREG,
2171            &NOREG,
2172        );
2173    }
2174}
2175
2176impl<'a> MmxPunpcklwdEmitter<Mm, Mem> for Assembler<'a> {
2177    fn mmx_punpcklwd(&mut self, op0: Mm, op1: Mem) {
2178        self.emit(
2179            MMX_PUNPCKLWDRM,
2180            op0.as_operand(),
2181            op1.as_operand(),
2182            &NOREG,
2183            &NOREG,
2184        );
2185    }
2186}
2187
2188/// `MMX_PXOR`.
2189///
2190/// Supported operand variants:
2191///
2192/// ```text
2193/// +---+----------+
2194/// | # | Operands |
2195/// +---+----------+
2196/// | 1 | Mm, Mem  |
2197/// | 2 | Mm, Mm   |
2198/// +---+----------+
2199/// ```
2200pub trait MmxPxorEmitter<A, B> {
2201    fn mmx_pxor(&mut self, op0: A, op1: B);
2202}
2203
2204impl<'a> MmxPxorEmitter<Mm, Mm> for Assembler<'a> {
2205    fn mmx_pxor(&mut self, op0: Mm, op1: Mm) {
2206        self.emit(
2207            MMX_PXORRR,
2208            op0.as_operand(),
2209            op1.as_operand(),
2210            &NOREG,
2211            &NOREG,
2212        );
2213    }
2214}
2215
2216impl<'a> MmxPxorEmitter<Mm, Mem> for Assembler<'a> {
2217    fn mmx_pxor(&mut self, op0: Mm, op1: Mem) {
2218        self.emit(
2219            MMX_PXORRM,
2220            op0.as_operand(),
2221            op1.as_operand(),
2222            &NOREG,
2223            &NOREG,
2224        );
2225    }
2226}
2227
2228impl<'a> Assembler<'a> {
2229    /// `MMX_EMMS`.
2230    ///
2231    /// Supported operand variants:
2232    ///
2233    /// ```text
2234    /// +---+----------+
2235    /// | # | Operands |
2236    /// +---+----------+
2237    /// | 1 | (none)   |
2238    /// +---+----------+
2239    /// ```
2240    #[inline]
2241    pub fn mmx_emms(&mut self)
2242    where
2243        Assembler<'a>: MmxEmmsEmitter,
2244    {
2245        <Self as MmxEmmsEmitter>::mmx_emms(self);
2246    }
2247    /// `MMX_MOVD_G2M`.
2248    ///
2249    /// Supported operand variants:
2250    ///
2251    /// ```text
2252    /// +---+----------+
2253    /// | # | Operands |
2254    /// +---+----------+
2255    /// | 1 | Mm, Gpd  |
2256    /// | 2 | Mm, Mem  |
2257    /// +---+----------+
2258    /// ```
2259    #[inline]
2260    pub fn mmx_movd_g2m<A, B>(&mut self, op0: A, op1: B)
2261    where
2262        Assembler<'a>: MmxMovdG2mEmitter<A, B>,
2263    {
2264        <Self as MmxMovdG2mEmitter<A, B>>::mmx_movd_g2m(self, op0, op1);
2265    }
2266    /// `MMX_MOVD_M2G`.
2267    ///
2268    /// Supported operand variants:
2269    ///
2270    /// ```text
2271    /// +---+----------+
2272    /// | # | Operands |
2273    /// +---+----------+
2274    /// | 1 | Gpd, Mm  |
2275    /// | 2 | Mem, Mm  |
2276    /// +---+----------+
2277    /// ```
2278    #[inline]
2279    pub fn mmx_movd_m2g<A, B>(&mut self, op0: A, op1: B)
2280    where
2281        Assembler<'a>: MmxMovdM2gEmitter<A, B>,
2282    {
2283        <Self as MmxMovdM2gEmitter<A, B>>::mmx_movd_m2g(self, op0, op1);
2284    }
2285    /// `MMX_MOVQ`.
2286    ///
2287    /// Supported operand variants:
2288    ///
2289    /// ```text
2290    /// +---+----------+
2291    /// | # | Operands |
2292    /// +---+----------+
2293    /// | 1 | Mem, Mm  |
2294    /// | 2 | Mm, Mem  |
2295    /// | 3 | Mm, Mm   |
2296    /// +---+----------+
2297    /// ```
2298    #[inline]
2299    pub fn mmx_movq<A, B>(&mut self, op0: A, op1: B)
2300    where
2301        Assembler<'a>: MmxMovqEmitter<A, B>,
2302    {
2303        <Self as MmxMovqEmitter<A, B>>::mmx_movq(self, op0, op1);
2304    }
2305    /// `MMX_MOVQ_G2M`.
2306    ///
2307    /// Supported operand variants:
2308    ///
2309    /// ```text
2310    /// +---+----------+
2311    /// | # | Operands |
2312    /// +---+----------+
2313    /// | 1 | Mm, Gpd  |
2314    /// | 2 | Mm, Mem  |
2315    /// +---+----------+
2316    /// ```
2317    #[inline]
2318    pub fn mmx_movq_g2m<A, B>(&mut self, op0: A, op1: B)
2319    where
2320        Assembler<'a>: MmxMovqG2mEmitter<A, B>,
2321    {
2322        <Self as MmxMovqG2mEmitter<A, B>>::mmx_movq_g2m(self, op0, op1);
2323    }
2324    /// `MMX_MOVQ_M2G`.
2325    ///
2326    /// Supported operand variants:
2327    ///
2328    /// ```text
2329    /// +---+----------+
2330    /// | # | Operands |
2331    /// +---+----------+
2332    /// | 1 | Gpd, Mm  |
2333    /// | 2 | Mem, Mm  |
2334    /// +---+----------+
2335    /// ```
2336    #[inline]
2337    pub fn mmx_movq_m2g<A, B>(&mut self, op0: A, op1: B)
2338    where
2339        Assembler<'a>: MmxMovqM2gEmitter<A, B>,
2340    {
2341        <Self as MmxMovqM2gEmitter<A, B>>::mmx_movq_m2g(self, op0, op1);
2342    }
2343    /// `MMX_PACKSSDW`.
2344    ///
2345    /// Supported operand variants:
2346    ///
2347    /// ```text
2348    /// +---+----------+
2349    /// | # | Operands |
2350    /// +---+----------+
2351    /// | 1 | Mm, Mem  |
2352    /// | 2 | Mm, Mm   |
2353    /// +---+----------+
2354    /// ```
2355    #[inline]
2356    pub fn mmx_packssdw<A, B>(&mut self, op0: A, op1: B)
2357    where
2358        Assembler<'a>: MmxPackssdwEmitter<A, B>,
2359    {
2360        <Self as MmxPackssdwEmitter<A, B>>::mmx_packssdw(self, op0, op1);
2361    }
2362    /// `MMX_PACKSSWB`.
2363    ///
2364    /// Supported operand variants:
2365    ///
2366    /// ```text
2367    /// +---+----------+
2368    /// | # | Operands |
2369    /// +---+----------+
2370    /// | 1 | Mm, Mem  |
2371    /// | 2 | Mm, Mm   |
2372    /// +---+----------+
2373    /// ```
2374    #[inline]
2375    pub fn mmx_packsswb<A, B>(&mut self, op0: A, op1: B)
2376    where
2377        Assembler<'a>: MmxPacksswbEmitter<A, B>,
2378    {
2379        <Self as MmxPacksswbEmitter<A, B>>::mmx_packsswb(self, op0, op1);
2380    }
2381    /// `MMX_PACKUSWB`.
2382    ///
2383    /// Supported operand variants:
2384    ///
2385    /// ```text
2386    /// +---+----------+
2387    /// | # | Operands |
2388    /// +---+----------+
2389    /// | 1 | Mm, Mem  |
2390    /// | 2 | Mm, Mm   |
2391    /// +---+----------+
2392    /// ```
2393    #[inline]
2394    pub fn mmx_packuswb<A, B>(&mut self, op0: A, op1: B)
2395    where
2396        Assembler<'a>: MmxPackuswbEmitter<A, B>,
2397    {
2398        <Self as MmxPackuswbEmitter<A, B>>::mmx_packuswb(self, op0, op1);
2399    }
2400    /// `MMX_PADDB`.
2401    ///
2402    /// Supported operand variants:
2403    ///
2404    /// ```text
2405    /// +---+----------+
2406    /// | # | Operands |
2407    /// +---+----------+
2408    /// | 1 | Mm, Mem  |
2409    /// | 2 | Mm, Mm   |
2410    /// +---+----------+
2411    /// ```
2412    #[inline]
2413    pub fn mmx_paddb<A, B>(&mut self, op0: A, op1: B)
2414    where
2415        Assembler<'a>: MmxPaddbEmitter<A, B>,
2416    {
2417        <Self as MmxPaddbEmitter<A, B>>::mmx_paddb(self, op0, op1);
2418    }
2419    /// `MMX_PADDD`.
2420    ///
2421    /// Supported operand variants:
2422    ///
2423    /// ```text
2424    /// +---+----------+
2425    /// | # | Operands |
2426    /// +---+----------+
2427    /// | 1 | Mm, Mem  |
2428    /// | 2 | Mm, Mm   |
2429    /// +---+----------+
2430    /// ```
2431    #[inline]
2432    pub fn mmx_paddd<A, B>(&mut self, op0: A, op1: B)
2433    where
2434        Assembler<'a>: MmxPadddEmitter<A, B>,
2435    {
2436        <Self as MmxPadddEmitter<A, B>>::mmx_paddd(self, op0, op1);
2437    }
2438    /// `MMX_PADDQ`.
2439    ///
2440    /// Supported operand variants:
2441    ///
2442    /// ```text
2443    /// +---+----------+
2444    /// | # | Operands |
2445    /// +---+----------+
2446    /// | 1 | Mm, Mem  |
2447    /// | 2 | Mm, Mm   |
2448    /// +---+----------+
2449    /// ```
2450    #[inline]
2451    pub fn mmx_paddq<A, B>(&mut self, op0: A, op1: B)
2452    where
2453        Assembler<'a>: MmxPaddqEmitter<A, B>,
2454    {
2455        <Self as MmxPaddqEmitter<A, B>>::mmx_paddq(self, op0, op1);
2456    }
2457    /// `MMX_PADDSB`.
2458    ///
2459    /// Supported operand variants:
2460    ///
2461    /// ```text
2462    /// +---+----------+
2463    /// | # | Operands |
2464    /// +---+----------+
2465    /// | 1 | Mm, Mem  |
2466    /// | 2 | Mm, Mm   |
2467    /// +---+----------+
2468    /// ```
2469    #[inline]
2470    pub fn mmx_paddsb<A, B>(&mut self, op0: A, op1: B)
2471    where
2472        Assembler<'a>: MmxPaddsbEmitter<A, B>,
2473    {
2474        <Self as MmxPaddsbEmitter<A, B>>::mmx_paddsb(self, op0, op1);
2475    }
2476    /// `MMX_PADDSW`.
2477    ///
2478    /// Supported operand variants:
2479    ///
2480    /// ```text
2481    /// +---+----------+
2482    /// | # | Operands |
2483    /// +---+----------+
2484    /// | 1 | Mm, Mem  |
2485    /// | 2 | Mm, Mm   |
2486    /// +---+----------+
2487    /// ```
2488    #[inline]
2489    pub fn mmx_paddsw<A, B>(&mut self, op0: A, op1: B)
2490    where
2491        Assembler<'a>: MmxPaddswEmitter<A, B>,
2492    {
2493        <Self as MmxPaddswEmitter<A, B>>::mmx_paddsw(self, op0, op1);
2494    }
2495    /// `MMX_PADDUSB`.
2496    ///
2497    /// Supported operand variants:
2498    ///
2499    /// ```text
2500    /// +---+----------+
2501    /// | # | Operands |
2502    /// +---+----------+
2503    /// | 1 | Mm, Mem  |
2504    /// | 2 | Mm, Mm   |
2505    /// +---+----------+
2506    /// ```
2507    #[inline]
2508    pub fn mmx_paddusb<A, B>(&mut self, op0: A, op1: B)
2509    where
2510        Assembler<'a>: MmxPaddusbEmitter<A, B>,
2511    {
2512        <Self as MmxPaddusbEmitter<A, B>>::mmx_paddusb(self, op0, op1);
2513    }
2514    /// `MMX_PADDUSW`.
2515    ///
2516    /// Supported operand variants:
2517    ///
2518    /// ```text
2519    /// +---+----------+
2520    /// | # | Operands |
2521    /// +---+----------+
2522    /// | 1 | Mm, Mem  |
2523    /// | 2 | Mm, Mm   |
2524    /// +---+----------+
2525    /// ```
2526    #[inline]
2527    pub fn mmx_paddusw<A, B>(&mut self, op0: A, op1: B)
2528    where
2529        Assembler<'a>: MmxPadduswEmitter<A, B>,
2530    {
2531        <Self as MmxPadduswEmitter<A, B>>::mmx_paddusw(self, op0, op1);
2532    }
2533    /// `MMX_PADDW`.
2534    ///
2535    /// Supported operand variants:
2536    ///
2537    /// ```text
2538    /// +---+----------+
2539    /// | # | Operands |
2540    /// +---+----------+
2541    /// | 1 | Mm, Mem  |
2542    /// | 2 | Mm, Mm   |
2543    /// +---+----------+
2544    /// ```
2545    #[inline]
2546    pub fn mmx_paddw<A, B>(&mut self, op0: A, op1: B)
2547    where
2548        Assembler<'a>: MmxPaddwEmitter<A, B>,
2549    {
2550        <Self as MmxPaddwEmitter<A, B>>::mmx_paddw(self, op0, op1);
2551    }
2552    /// `MMX_PAND`.
2553    ///
2554    /// Supported operand variants:
2555    ///
2556    /// ```text
2557    /// +---+----------+
2558    /// | # | Operands |
2559    /// +---+----------+
2560    /// | 1 | Mm, Mem  |
2561    /// | 2 | Mm, Mm   |
2562    /// +---+----------+
2563    /// ```
2564    #[inline]
2565    pub fn mmx_pand<A, B>(&mut self, op0: A, op1: B)
2566    where
2567        Assembler<'a>: MmxPandEmitter<A, B>,
2568    {
2569        <Self as MmxPandEmitter<A, B>>::mmx_pand(self, op0, op1);
2570    }
2571    /// `MMX_PANDN`.
2572    ///
2573    /// Supported operand variants:
2574    ///
2575    /// ```text
2576    /// +---+----------+
2577    /// | # | Operands |
2578    /// +---+----------+
2579    /// | 1 | Mm, Mem  |
2580    /// | 2 | Mm, Mm   |
2581    /// +---+----------+
2582    /// ```
2583    #[inline]
2584    pub fn mmx_pandn<A, B>(&mut self, op0: A, op1: B)
2585    where
2586        Assembler<'a>: MmxPandnEmitter<A, B>,
2587    {
2588        <Self as MmxPandnEmitter<A, B>>::mmx_pandn(self, op0, op1);
2589    }
2590    /// `MMX_PCMPEQB`.
2591    ///
2592    /// Supported operand variants:
2593    ///
2594    /// ```text
2595    /// +---+----------+
2596    /// | # | Operands |
2597    /// +---+----------+
2598    /// | 1 | Mm, Mem  |
2599    /// | 2 | Mm, Mm   |
2600    /// +---+----------+
2601    /// ```
2602    #[inline]
2603    pub fn mmx_pcmpeqb<A, B>(&mut self, op0: A, op1: B)
2604    where
2605        Assembler<'a>: MmxPcmpeqbEmitter<A, B>,
2606    {
2607        <Self as MmxPcmpeqbEmitter<A, B>>::mmx_pcmpeqb(self, op0, op1);
2608    }
2609    /// `MMX_PCMPEQD`.
2610    ///
2611    /// Supported operand variants:
2612    ///
2613    /// ```text
2614    /// +---+----------+
2615    /// | # | Operands |
2616    /// +---+----------+
2617    /// | 1 | Mm, Mem  |
2618    /// | 2 | Mm, Mm   |
2619    /// +---+----------+
2620    /// ```
2621    #[inline]
2622    pub fn mmx_pcmpeqd<A, B>(&mut self, op0: A, op1: B)
2623    where
2624        Assembler<'a>: MmxPcmpeqdEmitter<A, B>,
2625    {
2626        <Self as MmxPcmpeqdEmitter<A, B>>::mmx_pcmpeqd(self, op0, op1);
2627    }
2628    /// `MMX_PCMPEQW`.
2629    ///
2630    /// Supported operand variants:
2631    ///
2632    /// ```text
2633    /// +---+----------+
2634    /// | # | Operands |
2635    /// +---+----------+
2636    /// | 1 | Mm, Mem  |
2637    /// | 2 | Mm, Mm   |
2638    /// +---+----------+
2639    /// ```
2640    #[inline]
2641    pub fn mmx_pcmpeqw<A, B>(&mut self, op0: A, op1: B)
2642    where
2643        Assembler<'a>: MmxPcmpeqwEmitter<A, B>,
2644    {
2645        <Self as MmxPcmpeqwEmitter<A, B>>::mmx_pcmpeqw(self, op0, op1);
2646    }
2647    /// `MMX_PCMPGTB`.
2648    ///
2649    /// Supported operand variants:
2650    ///
2651    /// ```text
2652    /// +---+----------+
2653    /// | # | Operands |
2654    /// +---+----------+
2655    /// | 1 | Mm, Mem  |
2656    /// | 2 | Mm, Mm   |
2657    /// +---+----------+
2658    /// ```
2659    #[inline]
2660    pub fn mmx_pcmpgtb<A, B>(&mut self, op0: A, op1: B)
2661    where
2662        Assembler<'a>: MmxPcmpgtbEmitter<A, B>,
2663    {
2664        <Self as MmxPcmpgtbEmitter<A, B>>::mmx_pcmpgtb(self, op0, op1);
2665    }
2666    /// `MMX_PCMPGTD`.
2667    ///
2668    /// Supported operand variants:
2669    ///
2670    /// ```text
2671    /// +---+----------+
2672    /// | # | Operands |
2673    /// +---+----------+
2674    /// | 1 | Mm, Mem  |
2675    /// | 2 | Mm, Mm   |
2676    /// +---+----------+
2677    /// ```
2678    #[inline]
2679    pub fn mmx_pcmpgtd<A, B>(&mut self, op0: A, op1: B)
2680    where
2681        Assembler<'a>: MmxPcmpgtdEmitter<A, B>,
2682    {
2683        <Self as MmxPcmpgtdEmitter<A, B>>::mmx_pcmpgtd(self, op0, op1);
2684    }
2685    /// `MMX_PCMPGTW`.
2686    ///
2687    /// Supported operand variants:
2688    ///
2689    /// ```text
2690    /// +---+----------+
2691    /// | # | Operands |
2692    /// +---+----------+
2693    /// | 1 | Mm, Mem  |
2694    /// | 2 | Mm, Mm   |
2695    /// +---+----------+
2696    /// ```
2697    #[inline]
2698    pub fn mmx_pcmpgtw<A, B>(&mut self, op0: A, op1: B)
2699    where
2700        Assembler<'a>: MmxPcmpgtwEmitter<A, B>,
2701    {
2702        <Self as MmxPcmpgtwEmitter<A, B>>::mmx_pcmpgtw(self, op0, op1);
2703    }
2704    /// `MMX_PMADDWD`.
2705    ///
2706    /// Supported operand variants:
2707    ///
2708    /// ```text
2709    /// +---+----------+
2710    /// | # | Operands |
2711    /// +---+----------+
2712    /// | 1 | Mm, Mem  |
2713    /// | 2 | Mm, Mm   |
2714    /// +---+----------+
2715    /// ```
2716    #[inline]
2717    pub fn mmx_pmaddwd<A, B>(&mut self, op0: A, op1: B)
2718    where
2719        Assembler<'a>: MmxPmaddwdEmitter<A, B>,
2720    {
2721        <Self as MmxPmaddwdEmitter<A, B>>::mmx_pmaddwd(self, op0, op1);
2722    }
2723    /// `MMX_PMULHW`.
2724    ///
2725    /// Supported operand variants:
2726    ///
2727    /// ```text
2728    /// +---+----------+
2729    /// | # | Operands |
2730    /// +---+----------+
2731    /// | 1 | Mm, Mem  |
2732    /// | 2 | Mm, Mm   |
2733    /// +---+----------+
2734    /// ```
2735    #[inline]
2736    pub fn mmx_pmulhw<A, B>(&mut self, op0: A, op1: B)
2737    where
2738        Assembler<'a>: MmxPmulhwEmitter<A, B>,
2739    {
2740        <Self as MmxPmulhwEmitter<A, B>>::mmx_pmulhw(self, op0, op1);
2741    }
2742    /// `MMX_PMULLW`.
2743    ///
2744    /// Supported operand variants:
2745    ///
2746    /// ```text
2747    /// +---+----------+
2748    /// | # | Operands |
2749    /// +---+----------+
2750    /// | 1 | Mm, Mem  |
2751    /// | 2 | Mm, Mm   |
2752    /// +---+----------+
2753    /// ```
2754    #[inline]
2755    pub fn mmx_pmullw<A, B>(&mut self, op0: A, op1: B)
2756    where
2757        Assembler<'a>: MmxPmullwEmitter<A, B>,
2758    {
2759        <Self as MmxPmullwEmitter<A, B>>::mmx_pmullw(self, op0, op1);
2760    }
2761    /// `MMX_PMULUDQ`.
2762    ///
2763    /// Supported operand variants:
2764    ///
2765    /// ```text
2766    /// +---+----------+
2767    /// | # | Operands |
2768    /// +---+----------+
2769    /// | 1 | Mm, Mem  |
2770    /// | 2 | Mm, Mm   |
2771    /// +---+----------+
2772    /// ```
2773    #[inline]
2774    pub fn mmx_pmuludq<A, B>(&mut self, op0: A, op1: B)
2775    where
2776        Assembler<'a>: MmxPmuludqEmitter<A, B>,
2777    {
2778        <Self as MmxPmuludqEmitter<A, B>>::mmx_pmuludq(self, op0, op1);
2779    }
2780    /// `MMX_POR`.
2781    ///
2782    /// Supported operand variants:
2783    ///
2784    /// ```text
2785    /// +---+----------+
2786    /// | # | Operands |
2787    /// +---+----------+
2788    /// | 1 | Mm, Mem  |
2789    /// | 2 | Mm, Mm   |
2790    /// +---+----------+
2791    /// ```
2792    #[inline]
2793    pub fn mmx_por<A, B>(&mut self, op0: A, op1: B)
2794    where
2795        Assembler<'a>: MmxPorEmitter<A, B>,
2796    {
2797        <Self as MmxPorEmitter<A, B>>::mmx_por(self, op0, op1);
2798    }
2799    /// `MMX_PSLLD`.
2800    ///
2801    /// Supported operand variants:
2802    ///
2803    /// ```text
2804    /// +---+----------+
2805    /// | # | Operands |
2806    /// +---+----------+
2807    /// | 1 | Mm, Imm  |
2808    /// | 2 | Mm, Mem  |
2809    /// | 3 | Mm, Mm   |
2810    /// +---+----------+
2811    /// ```
2812    #[inline]
2813    pub fn mmx_pslld<A, B>(&mut self, op0: A, op1: B)
2814    where
2815        Assembler<'a>: MmxPslldEmitter<A, B>,
2816    {
2817        <Self as MmxPslldEmitter<A, B>>::mmx_pslld(self, op0, op1);
2818    }
2819    /// `MMX_PSLLQ`.
2820    ///
2821    /// Supported operand variants:
2822    ///
2823    /// ```text
2824    /// +---+----------+
2825    /// | # | Operands |
2826    /// +---+----------+
2827    /// | 1 | Mm, Imm  |
2828    /// | 2 | Mm, Mem  |
2829    /// | 3 | Mm, Mm   |
2830    /// +---+----------+
2831    /// ```
2832    #[inline]
2833    pub fn mmx_psllq<A, B>(&mut self, op0: A, op1: B)
2834    where
2835        Assembler<'a>: MmxPsllqEmitter<A, B>,
2836    {
2837        <Self as MmxPsllqEmitter<A, B>>::mmx_psllq(self, op0, op1);
2838    }
2839    /// `MMX_PSLLW`.
2840    ///
2841    /// Supported operand variants:
2842    ///
2843    /// ```text
2844    /// +---+----------+
2845    /// | # | Operands |
2846    /// +---+----------+
2847    /// | 1 | Mm, Imm  |
2848    /// | 2 | Mm, Mem  |
2849    /// | 3 | Mm, Mm   |
2850    /// +---+----------+
2851    /// ```
2852    #[inline]
2853    pub fn mmx_psllw<A, B>(&mut self, op0: A, op1: B)
2854    where
2855        Assembler<'a>: MmxPsllwEmitter<A, B>,
2856    {
2857        <Self as MmxPsllwEmitter<A, B>>::mmx_psllw(self, op0, op1);
2858    }
2859    /// `MMX_PSRAD`.
2860    ///
2861    /// Supported operand variants:
2862    ///
2863    /// ```text
2864    /// +---+----------+
2865    /// | # | Operands |
2866    /// +---+----------+
2867    /// | 1 | Mm, Imm  |
2868    /// | 2 | Mm, Mem  |
2869    /// | 3 | Mm, Mm   |
2870    /// +---+----------+
2871    /// ```
2872    #[inline]
2873    pub fn mmx_psrad<A, B>(&mut self, op0: A, op1: B)
2874    where
2875        Assembler<'a>: MmxPsradEmitter<A, B>,
2876    {
2877        <Self as MmxPsradEmitter<A, B>>::mmx_psrad(self, op0, op1);
2878    }
2879    /// `MMX_PSRAW`.
2880    ///
2881    /// Supported operand variants:
2882    ///
2883    /// ```text
2884    /// +---+----------+
2885    /// | # | Operands |
2886    /// +---+----------+
2887    /// | 1 | Mm, Imm  |
2888    /// | 2 | Mm, Mem  |
2889    /// | 3 | Mm, Mm   |
2890    /// +---+----------+
2891    /// ```
2892    #[inline]
2893    pub fn mmx_psraw<A, B>(&mut self, op0: A, op1: B)
2894    where
2895        Assembler<'a>: MmxPsrawEmitter<A, B>,
2896    {
2897        <Self as MmxPsrawEmitter<A, B>>::mmx_psraw(self, op0, op1);
2898    }
2899    /// `MMX_PSRLD`.
2900    ///
2901    /// Supported operand variants:
2902    ///
2903    /// ```text
2904    /// +---+----------+
2905    /// | # | Operands |
2906    /// +---+----------+
2907    /// | 1 | Mm, Imm  |
2908    /// | 2 | Mm, Mem  |
2909    /// | 3 | Mm, Mm   |
2910    /// +---+----------+
2911    /// ```
2912    #[inline]
2913    pub fn mmx_psrld<A, B>(&mut self, op0: A, op1: B)
2914    where
2915        Assembler<'a>: MmxPsrldEmitter<A, B>,
2916    {
2917        <Self as MmxPsrldEmitter<A, B>>::mmx_psrld(self, op0, op1);
2918    }
2919    /// `MMX_PSRLQ`.
2920    ///
2921    /// Supported operand variants:
2922    ///
2923    /// ```text
2924    /// +---+----------+
2925    /// | # | Operands |
2926    /// +---+----------+
2927    /// | 1 | Mm, Imm  |
2928    /// | 2 | Mm, Mem  |
2929    /// | 3 | Mm, Mm   |
2930    /// +---+----------+
2931    /// ```
2932    #[inline]
2933    pub fn mmx_psrlq<A, B>(&mut self, op0: A, op1: B)
2934    where
2935        Assembler<'a>: MmxPsrlqEmitter<A, B>,
2936    {
2937        <Self as MmxPsrlqEmitter<A, B>>::mmx_psrlq(self, op0, op1);
2938    }
2939    /// `MMX_PSRLW`.
2940    ///
2941    /// Supported operand variants:
2942    ///
2943    /// ```text
2944    /// +---+----------+
2945    /// | # | Operands |
2946    /// +---+----------+
2947    /// | 1 | Mm, Imm  |
2948    /// | 2 | Mm, Mem  |
2949    /// | 3 | Mm, Mm   |
2950    /// +---+----------+
2951    /// ```
2952    #[inline]
2953    pub fn mmx_psrlw<A, B>(&mut self, op0: A, op1: B)
2954    where
2955        Assembler<'a>: MmxPsrlwEmitter<A, B>,
2956    {
2957        <Self as MmxPsrlwEmitter<A, B>>::mmx_psrlw(self, op0, op1);
2958    }
2959    /// `MMX_PSUBB`.
2960    ///
2961    /// Supported operand variants:
2962    ///
2963    /// ```text
2964    /// +---+----------+
2965    /// | # | Operands |
2966    /// +---+----------+
2967    /// | 1 | Mm, Mem  |
2968    /// | 2 | Mm, Mm   |
2969    /// +---+----------+
2970    /// ```
2971    #[inline]
2972    pub fn mmx_psubb<A, B>(&mut self, op0: A, op1: B)
2973    where
2974        Assembler<'a>: MmxPsubbEmitter<A, B>,
2975    {
2976        <Self as MmxPsubbEmitter<A, B>>::mmx_psubb(self, op0, op1);
2977    }
2978    /// `MMX_PSUBD`.
2979    ///
2980    /// Supported operand variants:
2981    ///
2982    /// ```text
2983    /// +---+----------+
2984    /// | # | Operands |
2985    /// +---+----------+
2986    /// | 1 | Mm, Mem  |
2987    /// | 2 | Mm, Mm   |
2988    /// +---+----------+
2989    /// ```
2990    #[inline]
2991    pub fn mmx_psubd<A, B>(&mut self, op0: A, op1: B)
2992    where
2993        Assembler<'a>: MmxPsubdEmitter<A, B>,
2994    {
2995        <Self as MmxPsubdEmitter<A, B>>::mmx_psubd(self, op0, op1);
2996    }
2997    /// `MMX_PSUBQ`.
2998    ///
2999    /// Supported operand variants:
3000    ///
3001    /// ```text
3002    /// +---+----------+
3003    /// | # | Operands |
3004    /// +---+----------+
3005    /// | 1 | Mm, Mem  |
3006    /// | 2 | Mm, Mm   |
3007    /// +---+----------+
3008    /// ```
3009    #[inline]
3010    pub fn mmx_psubq<A, B>(&mut self, op0: A, op1: B)
3011    where
3012        Assembler<'a>: MmxPsubqEmitter<A, B>,
3013    {
3014        <Self as MmxPsubqEmitter<A, B>>::mmx_psubq(self, op0, op1);
3015    }
3016    /// `MMX_PSUBSB`.
3017    ///
3018    /// Supported operand variants:
3019    ///
3020    /// ```text
3021    /// +---+----------+
3022    /// | # | Operands |
3023    /// +---+----------+
3024    /// | 1 | Mm, Mem  |
3025    /// | 2 | Mm, Mm   |
3026    /// +---+----------+
3027    /// ```
3028    #[inline]
3029    pub fn mmx_psubsb<A, B>(&mut self, op0: A, op1: B)
3030    where
3031        Assembler<'a>: MmxPsubsbEmitter<A, B>,
3032    {
3033        <Self as MmxPsubsbEmitter<A, B>>::mmx_psubsb(self, op0, op1);
3034    }
3035    /// `MMX_PSUBSW`.
3036    ///
3037    /// Supported operand variants:
3038    ///
3039    /// ```text
3040    /// +---+----------+
3041    /// | # | Operands |
3042    /// +---+----------+
3043    /// | 1 | Mm, Mem  |
3044    /// | 2 | Mm, Mm   |
3045    /// +---+----------+
3046    /// ```
3047    #[inline]
3048    pub fn mmx_psubsw<A, B>(&mut self, op0: A, op1: B)
3049    where
3050        Assembler<'a>: MmxPsubswEmitter<A, B>,
3051    {
3052        <Self as MmxPsubswEmitter<A, B>>::mmx_psubsw(self, op0, op1);
3053    }
3054    /// `MMX_PSUBUSB`.
3055    ///
3056    /// Supported operand variants:
3057    ///
3058    /// ```text
3059    /// +---+----------+
3060    /// | # | Operands |
3061    /// +---+----------+
3062    /// | 1 | Mm, Mem  |
3063    /// | 2 | Mm, Mm   |
3064    /// +---+----------+
3065    /// ```
3066    #[inline]
3067    pub fn mmx_psubusb<A, B>(&mut self, op0: A, op1: B)
3068    where
3069        Assembler<'a>: MmxPsubusbEmitter<A, B>,
3070    {
3071        <Self as MmxPsubusbEmitter<A, B>>::mmx_psubusb(self, op0, op1);
3072    }
3073    /// `MMX_PSUBUSW`.
3074    ///
3075    /// Supported operand variants:
3076    ///
3077    /// ```text
3078    /// +---+----------+
3079    /// | # | Operands |
3080    /// +---+----------+
3081    /// | 1 | Mm, Mem  |
3082    /// | 2 | Mm, Mm   |
3083    /// +---+----------+
3084    /// ```
3085    #[inline]
3086    pub fn mmx_psubusw<A, B>(&mut self, op0: A, op1: B)
3087    where
3088        Assembler<'a>: MmxPsubuswEmitter<A, B>,
3089    {
3090        <Self as MmxPsubuswEmitter<A, B>>::mmx_psubusw(self, op0, op1);
3091    }
3092    /// `MMX_PSUBW`.
3093    ///
3094    /// Supported operand variants:
3095    ///
3096    /// ```text
3097    /// +---+----------+
3098    /// | # | Operands |
3099    /// +---+----------+
3100    /// | 1 | Mm, Mem  |
3101    /// | 2 | Mm, Mm   |
3102    /// +---+----------+
3103    /// ```
3104    #[inline]
3105    pub fn mmx_psubw<A, B>(&mut self, op0: A, op1: B)
3106    where
3107        Assembler<'a>: MmxPsubwEmitter<A, B>,
3108    {
3109        <Self as MmxPsubwEmitter<A, B>>::mmx_psubw(self, op0, op1);
3110    }
3111    /// `MMX_PUNPCKHBW`.
3112    ///
3113    /// Supported operand variants:
3114    ///
3115    /// ```text
3116    /// +---+----------+
3117    /// | # | Operands |
3118    /// +---+----------+
3119    /// | 1 | Mm, Mem  |
3120    /// | 2 | Mm, Mm   |
3121    /// +---+----------+
3122    /// ```
3123    #[inline]
3124    pub fn mmx_punpckhbw<A, B>(&mut self, op0: A, op1: B)
3125    where
3126        Assembler<'a>: MmxPunpckhbwEmitter<A, B>,
3127    {
3128        <Self as MmxPunpckhbwEmitter<A, B>>::mmx_punpckhbw(self, op0, op1);
3129    }
3130    /// `MMX_PUNPCKHDQ`.
3131    ///
3132    /// Supported operand variants:
3133    ///
3134    /// ```text
3135    /// +---+----------+
3136    /// | # | Operands |
3137    /// +---+----------+
3138    /// | 1 | Mm, Mem  |
3139    /// | 2 | Mm, Mm   |
3140    /// +---+----------+
3141    /// ```
3142    #[inline]
3143    pub fn mmx_punpckhdq<A, B>(&mut self, op0: A, op1: B)
3144    where
3145        Assembler<'a>: MmxPunpckhdqEmitter<A, B>,
3146    {
3147        <Self as MmxPunpckhdqEmitter<A, B>>::mmx_punpckhdq(self, op0, op1);
3148    }
3149    /// `MMX_PUNPCKHWD`.
3150    ///
3151    /// Supported operand variants:
3152    ///
3153    /// ```text
3154    /// +---+----------+
3155    /// | # | Operands |
3156    /// +---+----------+
3157    /// | 1 | Mm, Mem  |
3158    /// | 2 | Mm, Mm   |
3159    /// +---+----------+
3160    /// ```
3161    #[inline]
3162    pub fn mmx_punpckhwd<A, B>(&mut self, op0: A, op1: B)
3163    where
3164        Assembler<'a>: MmxPunpckhwdEmitter<A, B>,
3165    {
3166        <Self as MmxPunpckhwdEmitter<A, B>>::mmx_punpckhwd(self, op0, op1);
3167    }
3168    /// `MMX_PUNPCKLBW`.
3169    ///
3170    /// Supported operand variants:
3171    ///
3172    /// ```text
3173    /// +---+----------+
3174    /// | # | Operands |
3175    /// +---+----------+
3176    /// | 1 | Mm, Mem  |
3177    /// | 2 | Mm, Mm   |
3178    /// +---+----------+
3179    /// ```
3180    #[inline]
3181    pub fn mmx_punpcklbw<A, B>(&mut self, op0: A, op1: B)
3182    where
3183        Assembler<'a>: MmxPunpcklbwEmitter<A, B>,
3184    {
3185        <Self as MmxPunpcklbwEmitter<A, B>>::mmx_punpcklbw(self, op0, op1);
3186    }
3187    /// `MMX_PUNPCKLDQ`.
3188    ///
3189    /// Supported operand variants:
3190    ///
3191    /// ```text
3192    /// +---+----------+
3193    /// | # | Operands |
3194    /// +---+----------+
3195    /// | 1 | Mm, Mem  |
3196    /// | 2 | Mm, Mm   |
3197    /// +---+----------+
3198    /// ```
3199    #[inline]
3200    pub fn mmx_punpckldq<A, B>(&mut self, op0: A, op1: B)
3201    where
3202        Assembler<'a>: MmxPunpckldqEmitter<A, B>,
3203    {
3204        <Self as MmxPunpckldqEmitter<A, B>>::mmx_punpckldq(self, op0, op1);
3205    }
3206    /// `MMX_PUNPCKLWD`.
3207    ///
3208    /// Supported operand variants:
3209    ///
3210    /// ```text
3211    /// +---+----------+
3212    /// | # | Operands |
3213    /// +---+----------+
3214    /// | 1 | Mm, Mem  |
3215    /// | 2 | Mm, Mm   |
3216    /// +---+----------+
3217    /// ```
3218    #[inline]
3219    pub fn mmx_punpcklwd<A, B>(&mut self, op0: A, op1: B)
3220    where
3221        Assembler<'a>: MmxPunpcklwdEmitter<A, B>,
3222    {
3223        <Self as MmxPunpcklwdEmitter<A, B>>::mmx_punpcklwd(self, op0, op1);
3224    }
3225    /// `MMX_PXOR`.
3226    ///
3227    /// Supported operand variants:
3228    ///
3229    /// ```text
3230    /// +---+----------+
3231    /// | # | Operands |
3232    /// +---+----------+
3233    /// | 1 | Mm, Mem  |
3234    /// | 2 | Mm, Mm   |
3235    /// +---+----------+
3236    /// ```
3237    #[inline]
3238    pub fn mmx_pxor<A, B>(&mut self, op0: A, op1: B)
3239    where
3240        Assembler<'a>: MmxPxorEmitter<A, B>,
3241    {
3242        <Self as MmxPxorEmitter<A, B>>::mmx_pxor(self, op0, op1);
3243    }
3244}
asmkit/x86/features/MMX.rs

asmkit/x86/features/
MMX.rs
