asmkit/x86/features/
SSE2.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/// `LFENCE`.
11///
12/// Supported operand variants:
13///
14/// ```text
15/// +---+----------+
16/// | # | Operands |
17/// +---+----------+
18/// | 1 | (none)   |
19/// +---+----------+
20/// ```
21pub trait LfenceEmitter {
22    fn lfence(&mut self);
23}
24
25impl<'a> LfenceEmitter for Assembler<'a> {
26    fn lfence(&mut self) {
27        self.emit(LFENCE, &NOREG, &NOREG, &NOREG, &NOREG);
28    }
29}
30
31/// `MFENCE`.
32///
33/// Supported operand variants:
34///
35/// ```text
36/// +---+----------+
37/// | # | Operands |
38/// +---+----------+
39/// | 1 | (none)   |
40/// +---+----------+
41/// ```
42pub trait MfenceEmitter {
43    fn mfence(&mut self);
44}
45
46impl<'a> MfenceEmitter for Assembler<'a> {
47    fn mfence(&mut self) {
48        self.emit(MFENCE, &NOREG, &NOREG, &NOREG, &NOREG);
49    }
50}
51
52/// `MMX_CVTPD2PI`.
53///
54/// Supported operand variants:
55///
56/// ```text
57/// +---+----------+
58/// | # | Operands |
59/// +---+----------+
60/// | 1 | Mm, Mem  |
61/// | 2 | Mm, Xmm  |
62/// +---+----------+
63/// ```
64pub trait MmxCvtpd2piEmitter<A, B> {
65    fn mmx_cvtpd2pi(&mut self, op0: A, op1: B);
66}
67
68impl<'a> MmxCvtpd2piEmitter<Mm, Xmm> for Assembler<'a> {
69    fn mmx_cvtpd2pi(&mut self, op0: Mm, op1: Xmm) {
70        self.emit(
71            MMX_CVTPD2PIRR,
72            op0.as_operand(),
73            op1.as_operand(),
74            &NOREG,
75            &NOREG,
76        );
77    }
78}
79
80impl<'a> MmxCvtpd2piEmitter<Mm, Mem> for Assembler<'a> {
81    fn mmx_cvtpd2pi(&mut self, op0: Mm, op1: Mem) {
82        self.emit(
83            MMX_CVTPD2PIRM,
84            op0.as_operand(),
85            op1.as_operand(),
86            &NOREG,
87            &NOREG,
88        );
89    }
90}
91
92/// `MMX_CVTPI2PD`.
93///
94/// Supported operand variants:
95///
96/// ```text
97/// +---+----------+
98/// | # | Operands |
99/// +---+----------+
100/// | 1 | Xmm, Mem |
101/// | 2 | Xmm, Mm  |
102/// +---+----------+
103/// ```
104pub trait MmxCvtpi2pdEmitter<A, B> {
105    fn mmx_cvtpi2pd(&mut self, op0: A, op1: B);
106}
107
108impl<'a> MmxCvtpi2pdEmitter<Xmm, Mm> for Assembler<'a> {
109    fn mmx_cvtpi2pd(&mut self, op0: Xmm, op1: Mm) {
110        self.emit(
111            MMX_CVTPI2PDRR,
112            op0.as_operand(),
113            op1.as_operand(),
114            &NOREG,
115            &NOREG,
116        );
117    }
118}
119
120impl<'a> MmxCvtpi2pdEmitter<Xmm, Mem> for Assembler<'a> {
121    fn mmx_cvtpi2pd(&mut self, op0: Xmm, op1: Mem) {
122        self.emit(
123            MMX_CVTPI2PDRM,
124            op0.as_operand(),
125            op1.as_operand(),
126            &NOREG,
127            &NOREG,
128        );
129    }
130}
131
132/// `MMX_CVTPI2PS`.
133///
134/// Supported operand variants:
135///
136/// ```text
137/// +---+----------+
138/// | # | Operands |
139/// +---+----------+
140/// | 1 | Xmm, Mem |
141/// | 2 | Xmm, Mm  |
142/// +---+----------+
143/// ```
144pub trait MmxCvtpi2psEmitter<A, B> {
145    fn mmx_cvtpi2ps(&mut self, op0: A, op1: B);
146}
147
148impl<'a> MmxCvtpi2psEmitter<Xmm, Mm> for Assembler<'a> {
149    fn mmx_cvtpi2ps(&mut self, op0: Xmm, op1: Mm) {
150        self.emit(
151            MMX_CVTPI2PSRR,
152            op0.as_operand(),
153            op1.as_operand(),
154            &NOREG,
155            &NOREG,
156        );
157    }
158}
159
160impl<'a> MmxCvtpi2psEmitter<Xmm, Mem> for Assembler<'a> {
161    fn mmx_cvtpi2ps(&mut self, op0: Xmm, op1: Mem) {
162        self.emit(
163            MMX_CVTPI2PSRM,
164            op0.as_operand(),
165            op1.as_operand(),
166            &NOREG,
167            &NOREG,
168        );
169    }
170}
171
172/// `MMX_CVTPS2PI`.
173///
174/// Supported operand variants:
175///
176/// ```text
177/// +---+----------+
178/// | # | Operands |
179/// +---+----------+
180/// | 1 | Mm, Mem  |
181/// | 2 | Mm, Xmm  |
182/// +---+----------+
183/// ```
184pub trait MmxCvtps2piEmitter<A, B> {
185    fn mmx_cvtps2pi(&mut self, op0: A, op1: B);
186}
187
188impl<'a> MmxCvtps2piEmitter<Mm, Xmm> for Assembler<'a> {
189    fn mmx_cvtps2pi(&mut self, op0: Mm, op1: Xmm) {
190        self.emit(
191            MMX_CVTPS2PIRR,
192            op0.as_operand(),
193            op1.as_operand(),
194            &NOREG,
195            &NOREG,
196        );
197    }
198}
199
200impl<'a> MmxCvtps2piEmitter<Mm, Mem> for Assembler<'a> {
201    fn mmx_cvtps2pi(&mut self, op0: Mm, op1: Mem) {
202        self.emit(
203            MMX_CVTPS2PIRM,
204            op0.as_operand(),
205            op1.as_operand(),
206            &NOREG,
207            &NOREG,
208        );
209    }
210}
211
212/// `MMX_CVTTPD2PI`.
213///
214/// Supported operand variants:
215///
216/// ```text
217/// +---+----------+
218/// | # | Operands |
219/// +---+----------+
220/// | 1 | Mm, Mem  |
221/// | 2 | Mm, Xmm  |
222/// +---+----------+
223/// ```
224pub trait MmxCvttpd2piEmitter<A, B> {
225    fn mmx_cvttpd2pi(&mut self, op0: A, op1: B);
226}
227
228impl<'a> MmxCvttpd2piEmitter<Mm, Xmm> for Assembler<'a> {
229    fn mmx_cvttpd2pi(&mut self, op0: Mm, op1: Xmm) {
230        self.emit(
231            MMX_CVTTPD2PIRR,
232            op0.as_operand(),
233            op1.as_operand(),
234            &NOREG,
235            &NOREG,
236        );
237    }
238}
239
240impl<'a> MmxCvttpd2piEmitter<Mm, Mem> for Assembler<'a> {
241    fn mmx_cvttpd2pi(&mut self, op0: Mm, op1: Mem) {
242        self.emit(
243            MMX_CVTTPD2PIRM,
244            op0.as_operand(),
245            op1.as_operand(),
246            &NOREG,
247            &NOREG,
248        );
249    }
250}
251
252/// `MMX_CVTTPS2PI`.
253///
254/// Supported operand variants:
255///
256/// ```text
257/// +---+----------+
258/// | # | Operands |
259/// +---+----------+
260/// | 1 | Mm, Mem  |
261/// | 2 | Mm, Xmm  |
262/// +---+----------+
263/// ```
264pub trait MmxCvttps2piEmitter<A, B> {
265    fn mmx_cvttps2pi(&mut self, op0: A, op1: B);
266}
267
268impl<'a> MmxCvttps2piEmitter<Mm, Xmm> for Assembler<'a> {
269    fn mmx_cvttps2pi(&mut self, op0: Mm, op1: Xmm) {
270        self.emit(
271            MMX_CVTTPS2PIRR,
272            op0.as_operand(),
273            op1.as_operand(),
274            &NOREG,
275            &NOREG,
276        );
277    }
278}
279
280impl<'a> MmxCvttps2piEmitter<Mm, Mem> for Assembler<'a> {
281    fn mmx_cvttps2pi(&mut self, op0: Mm, op1: Mem) {
282        self.emit(
283            MMX_CVTTPS2PIRM,
284            op0.as_operand(),
285            op1.as_operand(),
286            &NOREG,
287            &NOREG,
288        );
289    }
290}
291
292/// `MOVNTI`.
293///
294/// Supported operand variants:
295///
296/// ```text
297/// +---+----------+
298/// | # | Operands |
299/// +---+----------+
300/// | 1 | Mem, Gpd |
301/// | 2 | Mem, Gpq |
302/// +---+----------+
303/// ```
304pub trait MovntiEmitter<A, B> {
305    fn movnti(&mut self, op0: A, op1: B);
306}
307
308impl<'a> MovntiEmitter<Mem, Gpd> for Assembler<'a> {
309    fn movnti(&mut self, op0: Mem, op1: Gpd) {
310        self.emit(
311            MOVNTI32MR,
312            op0.as_operand(),
313            op1.as_operand(),
314            &NOREG,
315            &NOREG,
316        );
317    }
318}
319
320impl<'a> MovntiEmitter<Mem, Gpq> for Assembler<'a> {
321    fn movnti(&mut self, op0: Mem, op1: Gpq) {
322        self.emit(
323            MOVNTI64MR,
324            op0.as_operand(),
325            op1.as_operand(),
326            &NOREG,
327            &NOREG,
328        );
329    }
330}
331
332/// `SSE_ADDPD`.
333///
334/// Supported operand variants:
335///
336/// ```text
337/// +---+----------+
338/// | # | Operands |
339/// +---+----------+
340/// | 1 | Xmm, Mem |
341/// | 2 | Xmm, Xmm |
342/// +---+----------+
343/// ```
344pub trait SseAddpdEmitter<A, B> {
345    fn sse_addpd(&mut self, op0: A, op1: B);
346}
347
348impl<'a> SseAddpdEmitter<Xmm, Xmm> for Assembler<'a> {
349    fn sse_addpd(&mut self, op0: Xmm, op1: Xmm) {
350        self.emit(
351            SSE_ADDPDRR,
352            op0.as_operand(),
353            op1.as_operand(),
354            &NOREG,
355            &NOREG,
356        );
357    }
358}
359
360impl<'a> SseAddpdEmitter<Xmm, Mem> for Assembler<'a> {
361    fn sse_addpd(&mut self, op0: Xmm, op1: Mem) {
362        self.emit(
363            SSE_ADDPDRM,
364            op0.as_operand(),
365            op1.as_operand(),
366            &NOREG,
367            &NOREG,
368        );
369    }
370}
371
372/// `SSE_ADDSD`.
373///
374/// Supported operand variants:
375///
376/// ```text
377/// +---+----------+
378/// | # | Operands |
379/// +---+----------+
380/// | 1 | Xmm, Mem |
381/// | 2 | Xmm, Xmm |
382/// +---+----------+
383/// ```
384pub trait SseAddsdEmitter<A, B> {
385    fn sse_addsd(&mut self, op0: A, op1: B);
386}
387
388impl<'a> SseAddsdEmitter<Xmm, Xmm> for Assembler<'a> {
389    fn sse_addsd(&mut self, op0: Xmm, op1: Xmm) {
390        self.emit(
391            SSE_ADDSDRR,
392            op0.as_operand(),
393            op1.as_operand(),
394            &NOREG,
395            &NOREG,
396        );
397    }
398}
399
400impl<'a> SseAddsdEmitter<Xmm, Mem> for Assembler<'a> {
401    fn sse_addsd(&mut self, op0: Xmm, op1: Mem) {
402        self.emit(
403            SSE_ADDSDRM,
404            op0.as_operand(),
405            op1.as_operand(),
406            &NOREG,
407            &NOREG,
408        );
409    }
410}
411
412/// `SSE_ANDNPD`.
413///
414/// Supported operand variants:
415///
416/// ```text
417/// +---+----------+
418/// | # | Operands |
419/// +---+----------+
420/// | 1 | Xmm, Mem |
421/// | 2 | Xmm, Xmm |
422/// +---+----------+
423/// ```
424pub trait SseAndnpdEmitter<A, B> {
425    fn sse_andnpd(&mut self, op0: A, op1: B);
426}
427
428impl<'a> SseAndnpdEmitter<Xmm, Xmm> for Assembler<'a> {
429    fn sse_andnpd(&mut self, op0: Xmm, op1: Xmm) {
430        self.emit(
431            SSE_ANDNPDRR,
432            op0.as_operand(),
433            op1.as_operand(),
434            &NOREG,
435            &NOREG,
436        );
437    }
438}
439
440impl<'a> SseAndnpdEmitter<Xmm, Mem> for Assembler<'a> {
441    fn sse_andnpd(&mut self, op0: Xmm, op1: Mem) {
442        self.emit(
443            SSE_ANDNPDRM,
444            op0.as_operand(),
445            op1.as_operand(),
446            &NOREG,
447            &NOREG,
448        );
449    }
450}
451
452/// `SSE_ANDPD`.
453///
454/// Supported operand variants:
455///
456/// ```text
457/// +---+----------+
458/// | # | Operands |
459/// +---+----------+
460/// | 1 | Xmm, Mem |
461/// | 2 | Xmm, Xmm |
462/// +---+----------+
463/// ```
464pub trait SseAndpdEmitter<A, B> {
465    fn sse_andpd(&mut self, op0: A, op1: B);
466}
467
468impl<'a> SseAndpdEmitter<Xmm, Xmm> for Assembler<'a> {
469    fn sse_andpd(&mut self, op0: Xmm, op1: Xmm) {
470        self.emit(
471            SSE_ANDPDRR,
472            op0.as_operand(),
473            op1.as_operand(),
474            &NOREG,
475            &NOREG,
476        );
477    }
478}
479
480impl<'a> SseAndpdEmitter<Xmm, Mem> for Assembler<'a> {
481    fn sse_andpd(&mut self, op0: Xmm, op1: Mem) {
482        self.emit(
483            SSE_ANDPDRM,
484            op0.as_operand(),
485            op1.as_operand(),
486            &NOREG,
487            &NOREG,
488        );
489    }
490}
491
492/// `SSE_CMPPD`.
493///
494/// Supported operand variants:
495///
496/// ```text
497/// +---+---------------+
498/// | # | Operands      |
499/// +---+---------------+
500/// | 1 | Xmm, Mem, Imm |
501/// | 2 | Xmm, Xmm, Imm |
502/// +---+---------------+
503/// ```
504pub trait SseCmppdEmitter<A, B, C> {
505    fn sse_cmppd(&mut self, op0: A, op1: B, op2: C);
506}
507
508impl<'a> SseCmppdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
509    fn sse_cmppd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
510        self.emit(
511            SSE_CMPPDRRI,
512            op0.as_operand(),
513            op1.as_operand(),
514            op2.as_operand(),
515            &NOREG,
516        );
517    }
518}
519
520impl<'a> SseCmppdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
521    fn sse_cmppd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
522        self.emit(
523            SSE_CMPPDRMI,
524            op0.as_operand(),
525            op1.as_operand(),
526            op2.as_operand(),
527            &NOREG,
528        );
529    }
530}
531
532/// `SSE_CMPSD`.
533///
534/// Supported operand variants:
535///
536/// ```text
537/// +---+---------------+
538/// | # | Operands      |
539/// +---+---------------+
540/// | 1 | Xmm, Mem, Imm |
541/// | 2 | Xmm, Xmm, Imm |
542/// +---+---------------+
543/// ```
544pub trait SseCmpsdEmitter<A, B, C> {
545    fn sse_cmpsd(&mut self, op0: A, op1: B, op2: C);
546}
547
548impl<'a> SseCmpsdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
549    fn sse_cmpsd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
550        self.emit(
551            SSE_CMPSDRRI,
552            op0.as_operand(),
553            op1.as_operand(),
554            op2.as_operand(),
555            &NOREG,
556        );
557    }
558}
559
560impl<'a> SseCmpsdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
561    fn sse_cmpsd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
562        self.emit(
563            SSE_CMPSDRMI,
564            op0.as_operand(),
565            op1.as_operand(),
566            op2.as_operand(),
567            &NOREG,
568        );
569    }
570}
571
572/// `SSE_COMISD`.
573///
574/// Supported operand variants:
575///
576/// ```text
577/// +---+----------+
578/// | # | Operands |
579/// +---+----------+
580/// | 1 | Xmm, Mem |
581/// | 2 | Xmm, Xmm |
582/// +---+----------+
583/// ```
584pub trait SseComisdEmitter<A, B> {
585    fn sse_comisd(&mut self, op0: A, op1: B);
586}
587
588impl<'a> SseComisdEmitter<Xmm, Xmm> for Assembler<'a> {
589    fn sse_comisd(&mut self, op0: Xmm, op1: Xmm) {
590        self.emit(
591            SSE_COMISDRR,
592            op0.as_operand(),
593            op1.as_operand(),
594            &NOREG,
595            &NOREG,
596        );
597    }
598}
599
600impl<'a> SseComisdEmitter<Xmm, Mem> for Assembler<'a> {
601    fn sse_comisd(&mut self, op0: Xmm, op1: Mem) {
602        self.emit(
603            SSE_COMISDRM,
604            op0.as_operand(),
605            op1.as_operand(),
606            &NOREG,
607            &NOREG,
608        );
609    }
610}
611
612/// `SSE_CVTDQ2PD`.
613///
614/// Supported operand variants:
615///
616/// ```text
617/// +---+----------+
618/// | # | Operands |
619/// +---+----------+
620/// | 1 | Xmm, Mem |
621/// | 2 | Xmm, Xmm |
622/// +---+----------+
623/// ```
624pub trait SseCvtdq2pdEmitter<A, B> {
625    fn sse_cvtdq2pd(&mut self, op0: A, op1: B);
626}
627
628impl<'a> SseCvtdq2pdEmitter<Xmm, Xmm> for Assembler<'a> {
629    fn sse_cvtdq2pd(&mut self, op0: Xmm, op1: Xmm) {
630        self.emit(
631            SSE_CVTDQ2PDRR,
632            op0.as_operand(),
633            op1.as_operand(),
634            &NOREG,
635            &NOREG,
636        );
637    }
638}
639
640impl<'a> SseCvtdq2pdEmitter<Xmm, Mem> for Assembler<'a> {
641    fn sse_cvtdq2pd(&mut self, op0: Xmm, op1: Mem) {
642        self.emit(
643            SSE_CVTDQ2PDRM,
644            op0.as_operand(),
645            op1.as_operand(),
646            &NOREG,
647            &NOREG,
648        );
649    }
650}
651
652/// `SSE_CVTDQ2PS`.
653///
654/// Supported operand variants:
655///
656/// ```text
657/// +---+----------+
658/// | # | Operands |
659/// +---+----------+
660/// | 1 | Xmm, Mem |
661/// | 2 | Xmm, Xmm |
662/// +---+----------+
663/// ```
664pub trait SseCvtdq2psEmitter<A, B> {
665    fn sse_cvtdq2ps(&mut self, op0: A, op1: B);
666}
667
668impl<'a> SseCvtdq2psEmitter<Xmm, Xmm> for Assembler<'a> {
669    fn sse_cvtdq2ps(&mut self, op0: Xmm, op1: Xmm) {
670        self.emit(
671            SSE_CVTDQ2PSRR,
672            op0.as_operand(),
673            op1.as_operand(),
674            &NOREG,
675            &NOREG,
676        );
677    }
678}
679
680impl<'a> SseCvtdq2psEmitter<Xmm, Mem> for Assembler<'a> {
681    fn sse_cvtdq2ps(&mut self, op0: Xmm, op1: Mem) {
682        self.emit(
683            SSE_CVTDQ2PSRM,
684            op0.as_operand(),
685            op1.as_operand(),
686            &NOREG,
687            &NOREG,
688        );
689    }
690}
691
692/// `SSE_CVTPD2DQ`.
693///
694/// Supported operand variants:
695///
696/// ```text
697/// +---+----------+
698/// | # | Operands |
699/// +---+----------+
700/// | 1 | Xmm, Mem |
701/// | 2 | Xmm, Xmm |
702/// +---+----------+
703/// ```
704pub trait SseCvtpd2dqEmitter<A, B> {
705    fn sse_cvtpd2dq(&mut self, op0: A, op1: B);
706}
707
708impl<'a> SseCvtpd2dqEmitter<Xmm, Xmm> for Assembler<'a> {
709    fn sse_cvtpd2dq(&mut self, op0: Xmm, op1: Xmm) {
710        self.emit(
711            SSE_CVTPD2DQRR,
712            op0.as_operand(),
713            op1.as_operand(),
714            &NOREG,
715            &NOREG,
716        );
717    }
718}
719
720impl<'a> SseCvtpd2dqEmitter<Xmm, Mem> for Assembler<'a> {
721    fn sse_cvtpd2dq(&mut self, op0: Xmm, op1: Mem) {
722        self.emit(
723            SSE_CVTPD2DQRM,
724            op0.as_operand(),
725            op1.as_operand(),
726            &NOREG,
727            &NOREG,
728        );
729    }
730}
731
732/// `SSE_CVTPD2PS`.
733///
734/// Supported operand variants:
735///
736/// ```text
737/// +---+----------+
738/// | # | Operands |
739/// +---+----------+
740/// | 1 | Xmm, Mem |
741/// | 2 | Xmm, Xmm |
742/// +---+----------+
743/// ```
744pub trait SseCvtpd2psEmitter<A, B> {
745    fn sse_cvtpd2ps(&mut self, op0: A, op1: B);
746}
747
748impl<'a> SseCvtpd2psEmitter<Xmm, Xmm> for Assembler<'a> {
749    fn sse_cvtpd2ps(&mut self, op0: Xmm, op1: Xmm) {
750        self.emit(
751            SSE_CVTPD2PSRR,
752            op0.as_operand(),
753            op1.as_operand(),
754            &NOREG,
755            &NOREG,
756        );
757    }
758}
759
760impl<'a> SseCvtpd2psEmitter<Xmm, Mem> for Assembler<'a> {
761    fn sse_cvtpd2ps(&mut self, op0: Xmm, op1: Mem) {
762        self.emit(
763            SSE_CVTPD2PSRM,
764            op0.as_operand(),
765            op1.as_operand(),
766            &NOREG,
767            &NOREG,
768        );
769    }
770}
771
772/// `SSE_CVTPS2DQ`.
773///
774/// Supported operand variants:
775///
776/// ```text
777/// +---+----------+
778/// | # | Operands |
779/// +---+----------+
780/// | 1 | Xmm, Mem |
781/// | 2 | Xmm, Xmm |
782/// +---+----------+
783/// ```
784pub trait SseCvtps2dqEmitter<A, B> {
785    fn sse_cvtps2dq(&mut self, op0: A, op1: B);
786}
787
788impl<'a> SseCvtps2dqEmitter<Xmm, Xmm> for Assembler<'a> {
789    fn sse_cvtps2dq(&mut self, op0: Xmm, op1: Xmm) {
790        self.emit(
791            SSE_CVTPS2DQRR,
792            op0.as_operand(),
793            op1.as_operand(),
794            &NOREG,
795            &NOREG,
796        );
797    }
798}
799
800impl<'a> SseCvtps2dqEmitter<Xmm, Mem> for Assembler<'a> {
801    fn sse_cvtps2dq(&mut self, op0: Xmm, op1: Mem) {
802        self.emit(
803            SSE_CVTPS2DQRM,
804            op0.as_operand(),
805            op1.as_operand(),
806            &NOREG,
807            &NOREG,
808        );
809    }
810}
811
812/// `SSE_CVTPS2PD`.
813///
814/// Supported operand variants:
815///
816/// ```text
817/// +---+----------+
818/// | # | Operands |
819/// +---+----------+
820/// | 1 | Xmm, Mem |
821/// | 2 | Xmm, Xmm |
822/// +---+----------+
823/// ```
824pub trait SseCvtps2pdEmitter<A, B> {
825    fn sse_cvtps2pd(&mut self, op0: A, op1: B);
826}
827
828impl<'a> SseCvtps2pdEmitter<Xmm, Xmm> for Assembler<'a> {
829    fn sse_cvtps2pd(&mut self, op0: Xmm, op1: Xmm) {
830        self.emit(
831            SSE_CVTPS2PDRR,
832            op0.as_operand(),
833            op1.as_operand(),
834            &NOREG,
835            &NOREG,
836        );
837    }
838}
839
840impl<'a> SseCvtps2pdEmitter<Xmm, Mem> for Assembler<'a> {
841    fn sse_cvtps2pd(&mut self, op0: Xmm, op1: Mem) {
842        self.emit(
843            SSE_CVTPS2PDRM,
844            op0.as_operand(),
845            op1.as_operand(),
846            &NOREG,
847            &NOREG,
848        );
849    }
850}
851
852/// `SSE_CVTSD2SI`.
853///
854/// Supported operand variants:
855///
856/// ```text
857/// +---+----------+
858/// | # | Operands |
859/// +---+----------+
860/// | 1 | Gpd, Mem |
861/// | 2 | Gpd, Xmm |
862/// | 3 | Gpq, Mem |
863/// | 4 | Gpq, Xmm |
864/// +---+----------+
865/// ```
866pub trait SseCvtsd2siEmitter<A, B> {
867    fn sse_cvtsd2si(&mut self, op0: A, op1: B);
868}
869
870impl<'a> SseCvtsd2siEmitter<Gpd, Xmm> for Assembler<'a> {
871    fn sse_cvtsd2si(&mut self, op0: Gpd, op1: Xmm) {
872        self.emit(
873            SSE_CVTSD2SI32RR,
874            op0.as_operand(),
875            op1.as_operand(),
876            &NOREG,
877            &NOREG,
878        );
879    }
880}
881
882impl<'a> SseCvtsd2siEmitter<Gpd, Mem> for Assembler<'a> {
883    fn sse_cvtsd2si(&mut self, op0: Gpd, op1: Mem) {
884        self.emit(
885            SSE_CVTSD2SI32RM,
886            op0.as_operand(),
887            op1.as_operand(),
888            &NOREG,
889            &NOREG,
890        );
891    }
892}
893
894impl<'a> SseCvtsd2siEmitter<Gpq, Xmm> for Assembler<'a> {
895    fn sse_cvtsd2si(&mut self, op0: Gpq, op1: Xmm) {
896        self.emit(
897            SSE_CVTSD2SI64RR,
898            op0.as_operand(),
899            op1.as_operand(),
900            &NOREG,
901            &NOREG,
902        );
903    }
904}
905
906impl<'a> SseCvtsd2siEmitter<Gpq, Mem> for Assembler<'a> {
907    fn sse_cvtsd2si(&mut self, op0: Gpq, op1: Mem) {
908        self.emit(
909            SSE_CVTSD2SI64RM,
910            op0.as_operand(),
911            op1.as_operand(),
912            &NOREG,
913            &NOREG,
914        );
915    }
916}
917
918/// `SSE_CVTSD2SS`.
919///
920/// Supported operand variants:
921///
922/// ```text
923/// +---+----------+
924/// | # | Operands |
925/// +---+----------+
926/// | 1 | Xmm, Mem |
927/// | 2 | Xmm, Xmm |
928/// +---+----------+
929/// ```
930pub trait SseCvtsd2ssEmitter<A, B> {
931    fn sse_cvtsd2ss(&mut self, op0: A, op1: B);
932}
933
934impl<'a> SseCvtsd2ssEmitter<Xmm, Xmm> for Assembler<'a> {
935    fn sse_cvtsd2ss(&mut self, op0: Xmm, op1: Xmm) {
936        self.emit(
937            SSE_CVTSD2SSRR,
938            op0.as_operand(),
939            op1.as_operand(),
940            &NOREG,
941            &NOREG,
942        );
943    }
944}
945
946impl<'a> SseCvtsd2ssEmitter<Xmm, Mem> for Assembler<'a> {
947    fn sse_cvtsd2ss(&mut self, op0: Xmm, op1: Mem) {
948        self.emit(
949            SSE_CVTSD2SSRM,
950            op0.as_operand(),
951            op1.as_operand(),
952            &NOREG,
953            &NOREG,
954        );
955    }
956}
957
958/// `SSE_CVTSI2SD`.
959///
960/// Supported operand variants:
961///
962/// ```text
963/// +---+----------+
964/// | # | Operands |
965/// +---+----------+
966/// | 1 | Xmm, Gpd |
967/// | 2 | Xmm, Gpq |
968/// | 3 | Xmm, Mem |
969/// +---+----------+
970/// ```
971pub trait SseCvtsi2sdEmitter<A, B> {
972    fn sse_cvtsi2sd(&mut self, op0: A, op1: B);
973}
974
975impl<'a> SseCvtsi2sdEmitter<Xmm, Gpd> for Assembler<'a> {
976    fn sse_cvtsi2sd(&mut self, op0: Xmm, op1: Gpd) {
977        self.emit(
978            SSE_CVTSI2SD32RR,
979            op0.as_operand(),
980            op1.as_operand(),
981            &NOREG,
982            &NOREG,
983        );
984    }
985}
986
987impl<'a> SseCvtsi2sdEmitter<Xmm, Mem> for Assembler<'a> {
988    fn sse_cvtsi2sd(&mut self, op0: Xmm, op1: Mem) {
989        self.emit(
990            SSE_CVTSI2SD32RM,
991            op0.as_operand(),
992            op1.as_operand(),
993            &NOREG,
994            &NOREG,
995        );
996    }
997}
998
999impl<'a> SseCvtsi2sdEmitter<Xmm, Gpq> for Assembler<'a> {
1000    fn sse_cvtsi2sd(&mut self, op0: Xmm, op1: Gpq) {
1001        self.emit(
1002            SSE_CVTSI2SD64RR,
1003            op0.as_operand(),
1004            op1.as_operand(),
1005            &NOREG,
1006            &NOREG,
1007        );
1008    }
1009}
1010
1011/// `SSE_CVTSS2SD`.
1012///
1013/// Supported operand variants:
1014///
1015/// ```text
1016/// +---+----------+
1017/// | # | Operands |
1018/// +---+----------+
1019/// | 1 | Xmm, Mem |
1020/// | 2 | Xmm, Xmm |
1021/// +---+----------+
1022/// ```
1023pub trait SseCvtss2sdEmitter<A, B> {
1024    fn sse_cvtss2sd(&mut self, op0: A, op1: B);
1025}
1026
1027impl<'a> SseCvtss2sdEmitter<Xmm, Xmm> for Assembler<'a> {
1028    fn sse_cvtss2sd(&mut self, op0: Xmm, op1: Xmm) {
1029        self.emit(
1030            SSE_CVTSS2SDRR,
1031            op0.as_operand(),
1032            op1.as_operand(),
1033            &NOREG,
1034            &NOREG,
1035        );
1036    }
1037}
1038
1039impl<'a> SseCvtss2sdEmitter<Xmm, Mem> for Assembler<'a> {
1040    fn sse_cvtss2sd(&mut self, op0: Xmm, op1: Mem) {
1041        self.emit(
1042            SSE_CVTSS2SDRM,
1043            op0.as_operand(),
1044            op1.as_operand(),
1045            &NOREG,
1046            &NOREG,
1047        );
1048    }
1049}
1050
1051/// `SSE_CVTTPD2DQ`.
1052///
1053/// Supported operand variants:
1054///
1055/// ```text
1056/// +---+----------+
1057/// | # | Operands |
1058/// +---+----------+
1059/// | 1 | Xmm, Mem |
1060/// | 2 | Xmm, Xmm |
1061/// +---+----------+
1062/// ```
1063pub trait SseCvttpd2dqEmitter<A, B> {
1064    fn sse_cvttpd2dq(&mut self, op0: A, op1: B);
1065}
1066
1067impl<'a> SseCvttpd2dqEmitter<Xmm, Xmm> for Assembler<'a> {
1068    fn sse_cvttpd2dq(&mut self, op0: Xmm, op1: Xmm) {
1069        self.emit(
1070            SSE_CVTTPD2DQRR,
1071            op0.as_operand(),
1072            op1.as_operand(),
1073            &NOREG,
1074            &NOREG,
1075        );
1076    }
1077}
1078
1079impl<'a> SseCvttpd2dqEmitter<Xmm, Mem> for Assembler<'a> {
1080    fn sse_cvttpd2dq(&mut self, op0: Xmm, op1: Mem) {
1081        self.emit(
1082            SSE_CVTTPD2DQRM,
1083            op0.as_operand(),
1084            op1.as_operand(),
1085            &NOREG,
1086            &NOREG,
1087        );
1088    }
1089}
1090
1091/// `SSE_CVTTPS2DQ`.
1092///
1093/// Supported operand variants:
1094///
1095/// ```text
1096/// +---+----------+
1097/// | # | Operands |
1098/// +---+----------+
1099/// | 1 | Xmm, Mem |
1100/// | 2 | Xmm, Xmm |
1101/// +---+----------+
1102/// ```
1103pub trait SseCvttps2dqEmitter<A, B> {
1104    fn sse_cvttps2dq(&mut self, op0: A, op1: B);
1105}
1106
1107impl<'a> SseCvttps2dqEmitter<Xmm, Xmm> for Assembler<'a> {
1108    fn sse_cvttps2dq(&mut self, op0: Xmm, op1: Xmm) {
1109        self.emit(
1110            SSE_CVTTPS2DQRR,
1111            op0.as_operand(),
1112            op1.as_operand(),
1113            &NOREG,
1114            &NOREG,
1115        );
1116    }
1117}
1118
1119impl<'a> SseCvttps2dqEmitter<Xmm, Mem> for Assembler<'a> {
1120    fn sse_cvttps2dq(&mut self, op0: Xmm, op1: Mem) {
1121        self.emit(
1122            SSE_CVTTPS2DQRM,
1123            op0.as_operand(),
1124            op1.as_operand(),
1125            &NOREG,
1126            &NOREG,
1127        );
1128    }
1129}
1130
1131/// `SSE_CVTTSD2SI`.
1132///
1133/// Supported operand variants:
1134///
1135/// ```text
1136/// +---+----------+
1137/// | # | Operands |
1138/// +---+----------+
1139/// | 1 | Gpd, Mem |
1140/// | 2 | Gpd, Xmm |
1141/// | 3 | Gpq, Mem |
1142/// | 4 | Gpq, Xmm |
1143/// +---+----------+
1144/// ```
1145pub trait SseCvttsd2siEmitter<A, B> {
1146    fn sse_cvttsd2si(&mut self, op0: A, op1: B);
1147}
1148
1149impl<'a> SseCvttsd2siEmitter<Gpd, Xmm> for Assembler<'a> {
1150    fn sse_cvttsd2si(&mut self, op0: Gpd, op1: Xmm) {
1151        self.emit(
1152            SSE_CVTTSD2SI32RR,
1153            op0.as_operand(),
1154            op1.as_operand(),
1155            &NOREG,
1156            &NOREG,
1157        );
1158    }
1159}
1160
1161impl<'a> SseCvttsd2siEmitter<Gpd, Mem> for Assembler<'a> {
1162    fn sse_cvttsd2si(&mut self, op0: Gpd, op1: Mem) {
1163        self.emit(
1164            SSE_CVTTSD2SI32RM,
1165            op0.as_operand(),
1166            op1.as_operand(),
1167            &NOREG,
1168            &NOREG,
1169        );
1170    }
1171}
1172
1173impl<'a> SseCvttsd2siEmitter<Gpq, Xmm> for Assembler<'a> {
1174    fn sse_cvttsd2si(&mut self, op0: Gpq, op1: Xmm) {
1175        self.emit(
1176            SSE_CVTTSD2SI64RR,
1177            op0.as_operand(),
1178            op1.as_operand(),
1179            &NOREG,
1180            &NOREG,
1181        );
1182    }
1183}
1184
1185impl<'a> SseCvttsd2siEmitter<Gpq, Mem> for Assembler<'a> {
1186    fn sse_cvttsd2si(&mut self, op0: Gpq, op1: Mem) {
1187        self.emit(
1188            SSE_CVTTSD2SI64RM,
1189            op0.as_operand(),
1190            op1.as_operand(),
1191            &NOREG,
1192            &NOREG,
1193        );
1194    }
1195}
1196
1197/// `SSE_DIVPD`.
1198///
1199/// Supported operand variants:
1200///
1201/// ```text
1202/// +---+----------+
1203/// | # | Operands |
1204/// +---+----------+
1205/// | 1 | Xmm, Mem |
1206/// | 2 | Xmm, Xmm |
1207/// +---+----------+
1208/// ```
1209pub trait SseDivpdEmitter<A, B> {
1210    fn sse_divpd(&mut self, op0: A, op1: B);
1211}
1212
1213impl<'a> SseDivpdEmitter<Xmm, Xmm> for Assembler<'a> {
1214    fn sse_divpd(&mut self, op0: Xmm, op1: Xmm) {
1215        self.emit(
1216            SSE_DIVPDRR,
1217            op0.as_operand(),
1218            op1.as_operand(),
1219            &NOREG,
1220            &NOREG,
1221        );
1222    }
1223}
1224
1225impl<'a> SseDivpdEmitter<Xmm, Mem> for Assembler<'a> {
1226    fn sse_divpd(&mut self, op0: Xmm, op1: Mem) {
1227        self.emit(
1228            SSE_DIVPDRM,
1229            op0.as_operand(),
1230            op1.as_operand(),
1231            &NOREG,
1232            &NOREG,
1233        );
1234    }
1235}
1236
1237/// `SSE_DIVSD`.
1238///
1239/// Supported operand variants:
1240///
1241/// ```text
1242/// +---+----------+
1243/// | # | Operands |
1244/// +---+----------+
1245/// | 1 | Xmm, Mem |
1246/// | 2 | Xmm, Xmm |
1247/// +---+----------+
1248/// ```
1249pub trait SseDivsdEmitter<A, B> {
1250    fn sse_divsd(&mut self, op0: A, op1: B);
1251}
1252
1253impl<'a> SseDivsdEmitter<Xmm, Xmm> for Assembler<'a> {
1254    fn sse_divsd(&mut self, op0: Xmm, op1: Xmm) {
1255        self.emit(
1256            SSE_DIVSDRR,
1257            op0.as_operand(),
1258            op1.as_operand(),
1259            &NOREG,
1260            &NOREG,
1261        );
1262    }
1263}
1264
1265impl<'a> SseDivsdEmitter<Xmm, Mem> for Assembler<'a> {
1266    fn sse_divsd(&mut self, op0: Xmm, op1: Mem) {
1267        self.emit(
1268            SSE_DIVSDRM,
1269            op0.as_operand(),
1270            op1.as_operand(),
1271            &NOREG,
1272            &NOREG,
1273        );
1274    }
1275}
1276
1277/// `SSE_MASKMOVDQU`.
1278///
1279/// Supported operand variants:
1280///
1281/// ```text
1282/// +---+----------+
1283/// | # | Operands |
1284/// +---+----------+
1285/// | 1 | Xmm, Xmm |
1286/// +---+----------+
1287/// ```
1288pub trait SseMaskmovdquEmitter<A, B> {
1289    fn sse_maskmovdqu(&mut self, op0: A, op1: B);
1290}
1291
1292impl<'a> SseMaskmovdquEmitter<Xmm, Xmm> for Assembler<'a> {
1293    fn sse_maskmovdqu(&mut self, op0: Xmm, op1: Xmm) {
1294        self.emit(
1295            SSE_MASKMOVDQURR,
1296            op0.as_operand(),
1297            op1.as_operand(),
1298            &NOREG,
1299            &NOREG,
1300        );
1301    }
1302}
1303
1304/// `SSE_MAXPD`.
1305///
1306/// Supported operand variants:
1307///
1308/// ```text
1309/// +---+----------+
1310/// | # | Operands |
1311/// +---+----------+
1312/// | 1 | Xmm, Mem |
1313/// | 2 | Xmm, Xmm |
1314/// +---+----------+
1315/// ```
1316pub trait SseMaxpdEmitter<A, B> {
1317    fn sse_maxpd(&mut self, op0: A, op1: B);
1318}
1319
1320impl<'a> SseMaxpdEmitter<Xmm, Xmm> for Assembler<'a> {
1321    fn sse_maxpd(&mut self, op0: Xmm, op1: Xmm) {
1322        self.emit(
1323            SSE_MAXPDRR,
1324            op0.as_operand(),
1325            op1.as_operand(),
1326            &NOREG,
1327            &NOREG,
1328        );
1329    }
1330}
1331
1332impl<'a> SseMaxpdEmitter<Xmm, Mem> for Assembler<'a> {
1333    fn sse_maxpd(&mut self, op0: Xmm, op1: Mem) {
1334        self.emit(
1335            SSE_MAXPDRM,
1336            op0.as_operand(),
1337            op1.as_operand(),
1338            &NOREG,
1339            &NOREG,
1340        );
1341    }
1342}
1343
1344/// `SSE_MAXSD`.
1345///
1346/// Supported operand variants:
1347///
1348/// ```text
1349/// +---+----------+
1350/// | # | Operands |
1351/// +---+----------+
1352/// | 1 | Xmm, Mem |
1353/// | 2 | Xmm, Xmm |
1354/// +---+----------+
1355/// ```
1356pub trait SseMaxsdEmitter<A, B> {
1357    fn sse_maxsd(&mut self, op0: A, op1: B);
1358}
1359
1360impl<'a> SseMaxsdEmitter<Xmm, Xmm> for Assembler<'a> {
1361    fn sse_maxsd(&mut self, op0: Xmm, op1: Xmm) {
1362        self.emit(
1363            SSE_MAXSDRR,
1364            op0.as_operand(),
1365            op1.as_operand(),
1366            &NOREG,
1367            &NOREG,
1368        );
1369    }
1370}
1371
1372impl<'a> SseMaxsdEmitter<Xmm, Mem> for Assembler<'a> {
1373    fn sse_maxsd(&mut self, op0: Xmm, op1: Mem) {
1374        self.emit(
1375            SSE_MAXSDRM,
1376            op0.as_operand(),
1377            op1.as_operand(),
1378            &NOREG,
1379            &NOREG,
1380        );
1381    }
1382}
1383
1384/// `SSE_MINPD`.
1385///
1386/// Supported operand variants:
1387///
1388/// ```text
1389/// +---+----------+
1390/// | # | Operands |
1391/// +---+----------+
1392/// | 1 | Xmm, Mem |
1393/// | 2 | Xmm, Xmm |
1394/// +---+----------+
1395/// ```
1396pub trait SseMinpdEmitter<A, B> {
1397    fn sse_minpd(&mut self, op0: A, op1: B);
1398}
1399
1400impl<'a> SseMinpdEmitter<Xmm, Xmm> for Assembler<'a> {
1401    fn sse_minpd(&mut self, op0: Xmm, op1: Xmm) {
1402        self.emit(
1403            SSE_MINPDRR,
1404            op0.as_operand(),
1405            op1.as_operand(),
1406            &NOREG,
1407            &NOREG,
1408        );
1409    }
1410}
1411
1412impl<'a> SseMinpdEmitter<Xmm, Mem> for Assembler<'a> {
1413    fn sse_minpd(&mut self, op0: Xmm, op1: Mem) {
1414        self.emit(
1415            SSE_MINPDRM,
1416            op0.as_operand(),
1417            op1.as_operand(),
1418            &NOREG,
1419            &NOREG,
1420        );
1421    }
1422}
1423
1424/// `SSE_MINSD`.
1425///
1426/// Supported operand variants:
1427///
1428/// ```text
1429/// +---+----------+
1430/// | # | Operands |
1431/// +---+----------+
1432/// | 1 | Xmm, Mem |
1433/// | 2 | Xmm, Xmm |
1434/// +---+----------+
1435/// ```
1436pub trait SseMinsdEmitter<A, B> {
1437    fn sse_minsd(&mut self, op0: A, op1: B);
1438}
1439
1440impl<'a> SseMinsdEmitter<Xmm, Xmm> for Assembler<'a> {
1441    fn sse_minsd(&mut self, op0: Xmm, op1: Xmm) {
1442        self.emit(
1443            SSE_MINSDRR,
1444            op0.as_operand(),
1445            op1.as_operand(),
1446            &NOREG,
1447            &NOREG,
1448        );
1449    }
1450}
1451
1452impl<'a> SseMinsdEmitter<Xmm, Mem> for Assembler<'a> {
1453    fn sse_minsd(&mut self, op0: Xmm, op1: Mem) {
1454        self.emit(
1455            SSE_MINSDRM,
1456            op0.as_operand(),
1457            op1.as_operand(),
1458            &NOREG,
1459            &NOREG,
1460        );
1461    }
1462}
1463
1464/// `SSE_MOVAPD`.
1465///
1466/// Supported operand variants:
1467///
1468/// ```text
1469/// +---+----------+
1470/// | # | Operands |
1471/// +---+----------+
1472/// | 1 | Mem, Xmm |
1473/// | 2 | Xmm, Mem |
1474/// | 3 | Xmm, Xmm |
1475/// +---+----------+
1476/// ```
1477pub trait SseMovapdEmitter<A, B> {
1478    fn sse_movapd(&mut self, op0: A, op1: B);
1479}
1480
1481impl<'a> SseMovapdEmitter<Xmm, Xmm> for Assembler<'a> {
1482    fn sse_movapd(&mut self, op0: Xmm, op1: Xmm) {
1483        self.emit(
1484            SSE_MOVAPDRR,
1485            op0.as_operand(),
1486            op1.as_operand(),
1487            &NOREG,
1488            &NOREG,
1489        );
1490    }
1491}
1492
1493impl<'a> SseMovapdEmitter<Xmm, Mem> for Assembler<'a> {
1494    fn sse_movapd(&mut self, op0: Xmm, op1: Mem) {
1495        self.emit(
1496            SSE_MOVAPDRM,
1497            op0.as_operand(),
1498            op1.as_operand(),
1499            &NOREG,
1500            &NOREG,
1501        );
1502    }
1503}
1504
1505impl<'a> SseMovapdEmitter<Mem, Xmm> for Assembler<'a> {
1506    fn sse_movapd(&mut self, op0: Mem, op1: Xmm) {
1507        self.emit(
1508            SSE_MOVAPDMR,
1509            op0.as_operand(),
1510            op1.as_operand(),
1511            &NOREG,
1512            &NOREG,
1513        );
1514    }
1515}
1516
1517/// `SSE_MOVDQA`.
1518///
1519/// Supported operand variants:
1520///
1521/// ```text
1522/// +---+----------+
1523/// | # | Operands |
1524/// +---+----------+
1525/// | 1 | Mem, Xmm |
1526/// | 2 | Xmm, Mem |
1527/// | 3 | Xmm, Xmm |
1528/// +---+----------+
1529/// ```
1530pub trait SseMovdqaEmitter<A, B> {
1531    fn sse_movdqa(&mut self, op0: A, op1: B);
1532}
1533
1534impl<'a> SseMovdqaEmitter<Xmm, Xmm> for Assembler<'a> {
1535    fn sse_movdqa(&mut self, op0: Xmm, op1: Xmm) {
1536        self.emit(
1537            SSE_MOVDQARR,
1538            op0.as_operand(),
1539            op1.as_operand(),
1540            &NOREG,
1541            &NOREG,
1542        );
1543    }
1544}
1545
1546impl<'a> SseMovdqaEmitter<Xmm, Mem> for Assembler<'a> {
1547    fn sse_movdqa(&mut self, op0: Xmm, op1: Mem) {
1548        self.emit(
1549            SSE_MOVDQARM,
1550            op0.as_operand(),
1551            op1.as_operand(),
1552            &NOREG,
1553            &NOREG,
1554        );
1555    }
1556}
1557
1558impl<'a> SseMovdqaEmitter<Mem, Xmm> for Assembler<'a> {
1559    fn sse_movdqa(&mut self, op0: Mem, op1: Xmm) {
1560        self.emit(
1561            SSE_MOVDQAMR,
1562            op0.as_operand(),
1563            op1.as_operand(),
1564            &NOREG,
1565            &NOREG,
1566        );
1567    }
1568}
1569
1570/// `SSE_MOVDQU`.
1571///
1572/// Supported operand variants:
1573///
1574/// ```text
1575/// +---+----------+
1576/// | # | Operands |
1577/// +---+----------+
1578/// | 1 | Mem, Xmm |
1579/// | 2 | Xmm, Mem |
1580/// | 3 | Xmm, Xmm |
1581/// +---+----------+
1582/// ```
1583pub trait SseMovdquEmitter<A, B> {
1584    fn sse_movdqu(&mut self, op0: A, op1: B);
1585}
1586
1587impl<'a> SseMovdquEmitter<Xmm, Xmm> for Assembler<'a> {
1588    fn sse_movdqu(&mut self, op0: Xmm, op1: Xmm) {
1589        self.emit(
1590            SSE_MOVDQURR,
1591            op0.as_operand(),
1592            op1.as_operand(),
1593            &NOREG,
1594            &NOREG,
1595        );
1596    }
1597}
1598
1599impl<'a> SseMovdquEmitter<Xmm, Mem> for Assembler<'a> {
1600    fn sse_movdqu(&mut self, op0: Xmm, op1: Mem) {
1601        self.emit(
1602            SSE_MOVDQURM,
1603            op0.as_operand(),
1604            op1.as_operand(),
1605            &NOREG,
1606            &NOREG,
1607        );
1608    }
1609}
1610
1611impl<'a> SseMovdquEmitter<Mem, Xmm> for Assembler<'a> {
1612    fn sse_movdqu(&mut self, op0: Mem, op1: Xmm) {
1613        self.emit(
1614            SSE_MOVDQUMR,
1615            op0.as_operand(),
1616            op1.as_operand(),
1617            &NOREG,
1618            &NOREG,
1619        );
1620    }
1621}
1622
1623/// `SSE_MOVD_G2X`.
1624///
1625/// Supported operand variants:
1626///
1627/// ```text
1628/// +---+----------+
1629/// | # | Operands |
1630/// +---+----------+
1631/// | 1 | Xmm, Gpd |
1632/// | 2 | Xmm, Mem |
1633/// +---+----------+
1634/// ```
1635pub trait SseMovdG2xEmitter<A, B> {
1636    fn sse_movd_g2x(&mut self, op0: A, op1: B);
1637}
1638
1639impl<'a> SseMovdG2xEmitter<Xmm, Gpd> for Assembler<'a> {
1640    fn sse_movd_g2x(&mut self, op0: Xmm, op1: Gpd) {
1641        self.emit(
1642            SSE_MOVD_G2XRR,
1643            op0.as_operand(),
1644            op1.as_operand(),
1645            &NOREG,
1646            &NOREG,
1647        );
1648    }
1649}
1650
1651impl<'a> SseMovdG2xEmitter<Xmm, Mem> for Assembler<'a> {
1652    fn sse_movd_g2x(&mut self, op0: Xmm, op1: Mem) {
1653        self.emit(
1654            SSE_MOVD_G2XRM,
1655            op0.as_operand(),
1656            op1.as_operand(),
1657            &NOREG,
1658            &NOREG,
1659        );
1660    }
1661}
1662
1663/// `SSE_MOVD_X2G`.
1664///
1665/// Supported operand variants:
1666///
1667/// ```text
1668/// +---+----------+
1669/// | # | Operands |
1670/// +---+----------+
1671/// | 1 | Gpd, Xmm |
1672/// | 2 | Mem, Xmm |
1673/// +---+----------+
1674/// ```
1675pub trait SseMovdX2gEmitter<A, B> {
1676    fn sse_movd_x2g(&mut self, op0: A, op1: B);
1677}
1678
1679impl<'a> SseMovdX2gEmitter<Gpd, Xmm> for Assembler<'a> {
1680    fn sse_movd_x2g(&mut self, op0: Gpd, op1: Xmm) {
1681        self.emit(
1682            SSE_MOVD_X2GRR,
1683            op0.as_operand(),
1684            op1.as_operand(),
1685            &NOREG,
1686            &NOREG,
1687        );
1688    }
1689}
1690
1691impl<'a> SseMovdX2gEmitter<Mem, Xmm> for Assembler<'a> {
1692    fn sse_movd_x2g(&mut self, op0: Mem, op1: Xmm) {
1693        self.emit(
1694            SSE_MOVD_X2GMR,
1695            op0.as_operand(),
1696            op1.as_operand(),
1697            &NOREG,
1698            &NOREG,
1699        );
1700    }
1701}
1702
1703/// `SSE_MOVHPD`.
1704///
1705/// Supported operand variants:
1706///
1707/// ```text
1708/// +---+----------+
1709/// | # | Operands |
1710/// +---+----------+
1711/// | 1 | Mem, Xmm |
1712/// | 2 | Xmm, Mem |
1713/// +---+----------+
1714/// ```
1715pub trait SseMovhpdEmitter<A, B> {
1716    fn sse_movhpd(&mut self, op0: A, op1: B);
1717}
1718
1719impl<'a> SseMovhpdEmitter<Xmm, Mem> for Assembler<'a> {
1720    fn sse_movhpd(&mut self, op0: Xmm, op1: Mem) {
1721        self.emit(
1722            SSE_MOVHPDRM,
1723            op0.as_operand(),
1724            op1.as_operand(),
1725            &NOREG,
1726            &NOREG,
1727        );
1728    }
1729}
1730
1731impl<'a> SseMovhpdEmitter<Mem, Xmm> for Assembler<'a> {
1732    fn sse_movhpd(&mut self, op0: Mem, op1: Xmm) {
1733        self.emit(
1734            SSE_MOVHPDMR,
1735            op0.as_operand(),
1736            op1.as_operand(),
1737            &NOREG,
1738            &NOREG,
1739        );
1740    }
1741}
1742
1743/// `SSE_MOVLPD`.
1744///
1745/// Supported operand variants:
1746///
1747/// ```text
1748/// +---+----------+
1749/// | # | Operands |
1750/// +---+----------+
1751/// | 1 | Mem, Xmm |
1752/// | 2 | Xmm, Mem |
1753/// +---+----------+
1754/// ```
1755pub trait SseMovlpdEmitter<A, B> {
1756    fn sse_movlpd(&mut self, op0: A, op1: B);
1757}
1758
1759impl<'a> SseMovlpdEmitter<Xmm, Mem> for Assembler<'a> {
1760    fn sse_movlpd(&mut self, op0: Xmm, op1: Mem) {
1761        self.emit(
1762            SSE_MOVLPDRM,
1763            op0.as_operand(),
1764            op1.as_operand(),
1765            &NOREG,
1766            &NOREG,
1767        );
1768    }
1769}
1770
1771impl<'a> SseMovlpdEmitter<Mem, Xmm> for Assembler<'a> {
1772    fn sse_movlpd(&mut self, op0: Mem, op1: Xmm) {
1773        self.emit(
1774            SSE_MOVLPDMR,
1775            op0.as_operand(),
1776            op1.as_operand(),
1777            &NOREG,
1778            &NOREG,
1779        );
1780    }
1781}
1782
1783/// `SSE_MOVMSKPD`.
1784///
1785/// Supported operand variants:
1786///
1787/// ```text
1788/// +---+----------+
1789/// | # | Operands |
1790/// +---+----------+
1791/// | 1 | Gpq, Xmm |
1792/// +---+----------+
1793/// ```
1794pub trait SseMovmskpdEmitter<A, B> {
1795    fn sse_movmskpd(&mut self, op0: A, op1: B);
1796}
1797
1798impl<'a> SseMovmskpdEmitter<Gpq, Xmm> for Assembler<'a> {
1799    fn sse_movmskpd(&mut self, op0: Gpq, op1: Xmm) {
1800        self.emit(
1801            SSE_MOVMSKPDRR,
1802            op0.as_operand(),
1803            op1.as_operand(),
1804            &NOREG,
1805            &NOREG,
1806        );
1807    }
1808}
1809
1810/// `SSE_MOVNTDQ`.
1811///
1812/// Supported operand variants:
1813///
1814/// ```text
1815/// +---+----------+
1816/// | # | Operands |
1817/// +---+----------+
1818/// | 1 | Mem, Xmm |
1819/// +---+----------+
1820/// ```
1821pub trait SseMovntdqEmitter<A, B> {
1822    fn sse_movntdq(&mut self, op0: A, op1: B);
1823}
1824
1825impl<'a> SseMovntdqEmitter<Mem, Xmm> for Assembler<'a> {
1826    fn sse_movntdq(&mut self, op0: Mem, op1: Xmm) {
1827        self.emit(
1828            SSE_MOVNTDQMR,
1829            op0.as_operand(),
1830            op1.as_operand(),
1831            &NOREG,
1832            &NOREG,
1833        );
1834    }
1835}
1836
1837/// `SSE_MOVNTPD`.
1838///
1839/// Supported operand variants:
1840///
1841/// ```text
1842/// +---+----------+
1843/// | # | Operands |
1844/// +---+----------+
1845/// | 1 | Mem, Xmm |
1846/// +---+----------+
1847/// ```
1848pub trait SseMovntpdEmitter<A, B> {
1849    fn sse_movntpd(&mut self, op0: A, op1: B);
1850}
1851
1852impl<'a> SseMovntpdEmitter<Mem, Xmm> for Assembler<'a> {
1853    fn sse_movntpd(&mut self, op0: Mem, op1: Xmm) {
1854        self.emit(
1855            SSE_MOVNTPDMR,
1856            op0.as_operand(),
1857            op1.as_operand(),
1858            &NOREG,
1859            &NOREG,
1860        );
1861    }
1862}
1863
1864/// `SSE_MOVNTSD`.
1865///
1866/// Supported operand variants:
1867///
1868/// ```text
1869/// +---+----------+
1870/// | # | Operands |
1871/// +---+----------+
1872/// | 1 | Mem, Xmm |
1873/// +---+----------+
1874/// ```
1875pub trait SseMovntsdEmitter<A, B> {
1876    fn sse_movntsd(&mut self, op0: A, op1: B);
1877}
1878
1879impl<'a> SseMovntsdEmitter<Mem, Xmm> for Assembler<'a> {
1880    fn sse_movntsd(&mut self, op0: Mem, op1: Xmm) {
1881        self.emit(
1882            SSE_MOVNTSDMR,
1883            op0.as_operand(),
1884            op1.as_operand(),
1885            &NOREG,
1886            &NOREG,
1887        );
1888    }
1889}
1890
1891/// `SSE_MOVQ`.
1892///
1893/// Supported operand variants:
1894///
1895/// ```text
1896/// +---+----------+
1897/// | # | Operands |
1898/// +---+----------+
1899/// | 1 | Mem, Xmm |
1900/// | 2 | Xmm, Mem |
1901/// | 3 | Xmm, Xmm |
1902/// +---+----------+
1903/// ```
1904pub trait SseMovqEmitter<A, B> {
1905    fn sse_movq(&mut self, op0: A, op1: B);
1906}
1907
1908impl<'a> SseMovqEmitter<Xmm, Xmm> for Assembler<'a> {
1909    fn sse_movq(&mut self, op0: Xmm, op1: Xmm) {
1910        self.emit(
1911            SSE_MOVQRR,
1912            op0.as_operand(),
1913            op1.as_operand(),
1914            &NOREG,
1915            &NOREG,
1916        );
1917    }
1918}
1919
1920impl<'a> SseMovqEmitter<Xmm, Mem> for Assembler<'a> {
1921    fn sse_movq(&mut self, op0: Xmm, op1: Mem) {
1922        self.emit(
1923            SSE_MOVQRM,
1924            op0.as_operand(),
1925            op1.as_operand(),
1926            &NOREG,
1927            &NOREG,
1928        );
1929    }
1930}
1931
1932impl<'a> SseMovqEmitter<Mem, Xmm> for Assembler<'a> {
1933    fn sse_movq(&mut self, op0: Mem, op1: Xmm) {
1934        self.emit(
1935            SSE_MOVQMR,
1936            op0.as_operand(),
1937            op1.as_operand(),
1938            &NOREG,
1939            &NOREG,
1940        );
1941    }
1942}
1943
1944/// `SSE_MOVQ_G2X`.
1945///
1946/// Supported operand variants:
1947///
1948/// ```text
1949/// +---+----------+
1950/// | # | Operands |
1951/// +---+----------+
1952/// | 1 | Xmm, Gpd |
1953/// | 2 | Xmm, Mem |
1954/// +---+----------+
1955/// ```
1956pub trait SseMovqG2xEmitter<A, B> {
1957    fn sse_movq_g2x(&mut self, op0: A, op1: B);
1958}
1959
1960impl<'a> SseMovqG2xEmitter<Xmm, Gpd> for Assembler<'a> {
1961    fn sse_movq_g2x(&mut self, op0: Xmm, op1: Gpd) {
1962        self.emit(
1963            SSE_MOVQ_G2XRR,
1964            op0.as_operand(),
1965            op1.as_operand(),
1966            &NOREG,
1967            &NOREG,
1968        );
1969    }
1970}
1971
1972impl<'a> SseMovqG2xEmitter<Xmm, Mem> for Assembler<'a> {
1973    fn sse_movq_g2x(&mut self, op0: Xmm, op1: Mem) {
1974        self.emit(
1975            SSE_MOVQ_G2XRM,
1976            op0.as_operand(),
1977            op1.as_operand(),
1978            &NOREG,
1979            &NOREG,
1980        );
1981    }
1982}
1983
1984/// `SSE_MOVQ_X2G`.
1985///
1986/// Supported operand variants:
1987///
1988/// ```text
1989/// +---+----------+
1990/// | # | Operands |
1991/// +---+----------+
1992/// | 1 | Gpd, Xmm |
1993/// | 2 | Mem, Xmm |
1994/// +---+----------+
1995/// ```
1996pub trait SseMovqX2gEmitter<A, B> {
1997    fn sse_movq_x2g(&mut self, op0: A, op1: B);
1998}
1999
2000impl<'a> SseMovqX2gEmitter<Gpd, Xmm> for Assembler<'a> {
2001    fn sse_movq_x2g(&mut self, op0: Gpd, op1: Xmm) {
2002        self.emit(
2003            SSE_MOVQ_X2GRR,
2004            op0.as_operand(),
2005            op1.as_operand(),
2006            &NOREG,
2007            &NOREG,
2008        );
2009    }
2010}
2011
2012impl<'a> SseMovqX2gEmitter<Mem, Xmm> for Assembler<'a> {
2013    fn sse_movq_x2g(&mut self, op0: Mem, op1: Xmm) {
2014        self.emit(
2015            SSE_MOVQ_X2GMR,
2016            op0.as_operand(),
2017            op1.as_operand(),
2018            &NOREG,
2019            &NOREG,
2020        );
2021    }
2022}
2023
2024/// `SSE_MOVSD`.
2025///
2026/// Supported operand variants:
2027///
2028/// ```text
2029/// +---+----------+
2030/// | # | Operands |
2031/// +---+----------+
2032/// | 1 | Mem, Xmm |
2033/// | 2 | Xmm, Mem |
2034/// | 3 | Xmm, Xmm |
2035/// +---+----------+
2036/// ```
2037pub trait SseMovsdEmitter<A, B> {
2038    fn sse_movsd(&mut self, op0: A, op1: B);
2039}
2040
2041impl<'a> SseMovsdEmitter<Xmm, Xmm> for Assembler<'a> {
2042    fn sse_movsd(&mut self, op0: Xmm, op1: Xmm) {
2043        self.emit(
2044            SSE_MOVSDRR,
2045            op0.as_operand(),
2046            op1.as_operand(),
2047            &NOREG,
2048            &NOREG,
2049        );
2050    }
2051}
2052
2053impl<'a> SseMovsdEmitter<Xmm, Mem> for Assembler<'a> {
2054    fn sse_movsd(&mut self, op0: Xmm, op1: Mem) {
2055        self.emit(
2056            SSE_MOVSDRM,
2057            op0.as_operand(),
2058            op1.as_operand(),
2059            &NOREG,
2060            &NOREG,
2061        );
2062    }
2063}
2064
2065impl<'a> SseMovsdEmitter<Mem, Xmm> for Assembler<'a> {
2066    fn sse_movsd(&mut self, op0: Mem, op1: Xmm) {
2067        self.emit(
2068            SSE_MOVSDMR,
2069            op0.as_operand(),
2070            op1.as_operand(),
2071            &NOREG,
2072            &NOREG,
2073        );
2074    }
2075}
2076
2077/// `SSE_MOVUPD`.
2078///
2079/// Supported operand variants:
2080///
2081/// ```text
2082/// +---+----------+
2083/// | # | Operands |
2084/// +---+----------+
2085/// | 1 | Mem, Xmm |
2086/// | 2 | Xmm, Mem |
2087/// | 3 | Xmm, Xmm |
2088/// +---+----------+
2089/// ```
2090pub trait SseMovupdEmitter<A, B> {
2091    fn sse_movupd(&mut self, op0: A, op1: B);
2092}
2093
2094impl<'a> SseMovupdEmitter<Xmm, Xmm> for Assembler<'a> {
2095    fn sse_movupd(&mut self, op0: Xmm, op1: Xmm) {
2096        self.emit(
2097            SSE_MOVUPDRR,
2098            op0.as_operand(),
2099            op1.as_operand(),
2100            &NOREG,
2101            &NOREG,
2102        );
2103    }
2104}
2105
2106impl<'a> SseMovupdEmitter<Xmm, Mem> for Assembler<'a> {
2107    fn sse_movupd(&mut self, op0: Xmm, op1: Mem) {
2108        self.emit(
2109            SSE_MOVUPDRM,
2110            op0.as_operand(),
2111            op1.as_operand(),
2112            &NOREG,
2113            &NOREG,
2114        );
2115    }
2116}
2117
2118impl<'a> SseMovupdEmitter<Mem, Xmm> for Assembler<'a> {
2119    fn sse_movupd(&mut self, op0: Mem, op1: Xmm) {
2120        self.emit(
2121            SSE_MOVUPDMR,
2122            op0.as_operand(),
2123            op1.as_operand(),
2124            &NOREG,
2125            &NOREG,
2126        );
2127    }
2128}
2129
2130/// `SSE_MULPD`.
2131///
2132/// Supported operand variants:
2133///
2134/// ```text
2135/// +---+----------+
2136/// | # | Operands |
2137/// +---+----------+
2138/// | 1 | Xmm, Mem |
2139/// | 2 | Xmm, Xmm |
2140/// +---+----------+
2141/// ```
2142pub trait SseMulpdEmitter<A, B> {
2143    fn sse_mulpd(&mut self, op0: A, op1: B);
2144}
2145
2146impl<'a> SseMulpdEmitter<Xmm, Xmm> for Assembler<'a> {
2147    fn sse_mulpd(&mut self, op0: Xmm, op1: Xmm) {
2148        self.emit(
2149            SSE_MULPDRR,
2150            op0.as_operand(),
2151            op1.as_operand(),
2152            &NOREG,
2153            &NOREG,
2154        );
2155    }
2156}
2157
2158impl<'a> SseMulpdEmitter<Xmm, Mem> for Assembler<'a> {
2159    fn sse_mulpd(&mut self, op0: Xmm, op1: Mem) {
2160        self.emit(
2161            SSE_MULPDRM,
2162            op0.as_operand(),
2163            op1.as_operand(),
2164            &NOREG,
2165            &NOREG,
2166        );
2167    }
2168}
2169
2170/// `SSE_MULSD`.
2171///
2172/// Supported operand variants:
2173///
2174/// ```text
2175/// +---+----------+
2176/// | # | Operands |
2177/// +---+----------+
2178/// | 1 | Xmm, Mem |
2179/// | 2 | Xmm, Xmm |
2180/// +---+----------+
2181/// ```
2182pub trait SseMulsdEmitter<A, B> {
2183    fn sse_mulsd(&mut self, op0: A, op1: B);
2184}
2185
2186impl<'a> SseMulsdEmitter<Xmm, Xmm> for Assembler<'a> {
2187    fn sse_mulsd(&mut self, op0: Xmm, op1: Xmm) {
2188        self.emit(
2189            SSE_MULSDRR,
2190            op0.as_operand(),
2191            op1.as_operand(),
2192            &NOREG,
2193            &NOREG,
2194        );
2195    }
2196}
2197
2198impl<'a> SseMulsdEmitter<Xmm, Mem> for Assembler<'a> {
2199    fn sse_mulsd(&mut self, op0: Xmm, op1: Mem) {
2200        self.emit(
2201            SSE_MULSDRM,
2202            op0.as_operand(),
2203            op1.as_operand(),
2204            &NOREG,
2205            &NOREG,
2206        );
2207    }
2208}
2209
2210/// `SSE_ORPD`.
2211///
2212/// Supported operand variants:
2213///
2214/// ```text
2215/// +---+----------+
2216/// | # | Operands |
2217/// +---+----------+
2218/// | 1 | Xmm, Mem |
2219/// | 2 | Xmm, Xmm |
2220/// +---+----------+
2221/// ```
2222pub trait SseOrpdEmitter<A, B> {
2223    fn sse_orpd(&mut self, op0: A, op1: B);
2224}
2225
2226impl<'a> SseOrpdEmitter<Xmm, Xmm> for Assembler<'a> {
2227    fn sse_orpd(&mut self, op0: Xmm, op1: Xmm) {
2228        self.emit(
2229            SSE_ORPDRR,
2230            op0.as_operand(),
2231            op1.as_operand(),
2232            &NOREG,
2233            &NOREG,
2234        );
2235    }
2236}
2237
2238impl<'a> SseOrpdEmitter<Xmm, Mem> for Assembler<'a> {
2239    fn sse_orpd(&mut self, op0: Xmm, op1: Mem) {
2240        self.emit(
2241            SSE_ORPDRM,
2242            op0.as_operand(),
2243            op1.as_operand(),
2244            &NOREG,
2245            &NOREG,
2246        );
2247    }
2248}
2249
2250/// `SSE_PACKSSDW`.
2251///
2252/// Supported operand variants:
2253///
2254/// ```text
2255/// +---+----------+
2256/// | # | Operands |
2257/// +---+----------+
2258/// | 1 | Xmm, Mem |
2259/// | 2 | Xmm, Xmm |
2260/// +---+----------+
2261/// ```
2262pub trait SsePackssdwEmitter<A, B> {
2263    fn sse_packssdw(&mut self, op0: A, op1: B);
2264}
2265
2266impl<'a> SsePackssdwEmitter<Xmm, Xmm> for Assembler<'a> {
2267    fn sse_packssdw(&mut self, op0: Xmm, op1: Xmm) {
2268        self.emit(
2269            SSE_PACKSSDWRR,
2270            op0.as_operand(),
2271            op1.as_operand(),
2272            &NOREG,
2273            &NOREG,
2274        );
2275    }
2276}
2277
2278impl<'a> SsePackssdwEmitter<Xmm, Mem> for Assembler<'a> {
2279    fn sse_packssdw(&mut self, op0: Xmm, op1: Mem) {
2280        self.emit(
2281            SSE_PACKSSDWRM,
2282            op0.as_operand(),
2283            op1.as_operand(),
2284            &NOREG,
2285            &NOREG,
2286        );
2287    }
2288}
2289
2290/// `SSE_PACKSSWB`.
2291///
2292/// Supported operand variants:
2293///
2294/// ```text
2295/// +---+----------+
2296/// | # | Operands |
2297/// +---+----------+
2298/// | 1 | Xmm, Mem |
2299/// | 2 | Xmm, Xmm |
2300/// +---+----------+
2301/// ```
2302pub trait SsePacksswbEmitter<A, B> {
2303    fn sse_packsswb(&mut self, op0: A, op1: B);
2304}
2305
2306impl<'a> SsePacksswbEmitter<Xmm, Xmm> for Assembler<'a> {
2307    fn sse_packsswb(&mut self, op0: Xmm, op1: Xmm) {
2308        self.emit(
2309            SSE_PACKSSWBRR,
2310            op0.as_operand(),
2311            op1.as_operand(),
2312            &NOREG,
2313            &NOREG,
2314        );
2315    }
2316}
2317
2318impl<'a> SsePacksswbEmitter<Xmm, Mem> for Assembler<'a> {
2319    fn sse_packsswb(&mut self, op0: Xmm, op1: Mem) {
2320        self.emit(
2321            SSE_PACKSSWBRM,
2322            op0.as_operand(),
2323            op1.as_operand(),
2324            &NOREG,
2325            &NOREG,
2326        );
2327    }
2328}
2329
2330/// `SSE_PACKUSWB`.
2331///
2332/// Supported operand variants:
2333///
2334/// ```text
2335/// +---+----------+
2336/// | # | Operands |
2337/// +---+----------+
2338/// | 1 | Xmm, Mem |
2339/// | 2 | Xmm, Xmm |
2340/// +---+----------+
2341/// ```
2342pub trait SsePackuswbEmitter<A, B> {
2343    fn sse_packuswb(&mut self, op0: A, op1: B);
2344}
2345
2346impl<'a> SsePackuswbEmitter<Xmm, Xmm> for Assembler<'a> {
2347    fn sse_packuswb(&mut self, op0: Xmm, op1: Xmm) {
2348        self.emit(
2349            SSE_PACKUSWBRR,
2350            op0.as_operand(),
2351            op1.as_operand(),
2352            &NOREG,
2353            &NOREG,
2354        );
2355    }
2356}
2357
2358impl<'a> SsePackuswbEmitter<Xmm, Mem> for Assembler<'a> {
2359    fn sse_packuswb(&mut self, op0: Xmm, op1: Mem) {
2360        self.emit(
2361            SSE_PACKUSWBRM,
2362            op0.as_operand(),
2363            op1.as_operand(),
2364            &NOREG,
2365            &NOREG,
2366        );
2367    }
2368}
2369
2370/// `SSE_PADDB`.
2371///
2372/// Supported operand variants:
2373///
2374/// ```text
2375/// +---+----------+
2376/// | # | Operands |
2377/// +---+----------+
2378/// | 1 | Xmm, Mem |
2379/// | 2 | Xmm, Xmm |
2380/// +---+----------+
2381/// ```
2382pub trait SsePaddbEmitter<A, B> {
2383    fn sse_paddb(&mut self, op0: A, op1: B);
2384}
2385
2386impl<'a> SsePaddbEmitter<Xmm, Xmm> for Assembler<'a> {
2387    fn sse_paddb(&mut self, op0: Xmm, op1: Xmm) {
2388        self.emit(
2389            SSE_PADDBRR,
2390            op0.as_operand(),
2391            op1.as_operand(),
2392            &NOREG,
2393            &NOREG,
2394        );
2395    }
2396}
2397
2398impl<'a> SsePaddbEmitter<Xmm, Mem> for Assembler<'a> {
2399    fn sse_paddb(&mut self, op0: Xmm, op1: Mem) {
2400        self.emit(
2401            SSE_PADDBRM,
2402            op0.as_operand(),
2403            op1.as_operand(),
2404            &NOREG,
2405            &NOREG,
2406        );
2407    }
2408}
2409
2410/// `SSE_PADDD`.
2411///
2412/// Supported operand variants:
2413///
2414/// ```text
2415/// +---+----------+
2416/// | # | Operands |
2417/// +---+----------+
2418/// | 1 | Xmm, Mem |
2419/// | 2 | Xmm, Xmm |
2420/// +---+----------+
2421/// ```
2422pub trait SsePadddEmitter<A, B> {
2423    fn sse_paddd(&mut self, op0: A, op1: B);
2424}
2425
2426impl<'a> SsePadddEmitter<Xmm, Xmm> for Assembler<'a> {
2427    fn sse_paddd(&mut self, op0: Xmm, op1: Xmm) {
2428        self.emit(
2429            SSE_PADDDRR,
2430            op0.as_operand(),
2431            op1.as_operand(),
2432            &NOREG,
2433            &NOREG,
2434        );
2435    }
2436}
2437
2438impl<'a> SsePadddEmitter<Xmm, Mem> for Assembler<'a> {
2439    fn sse_paddd(&mut self, op0: Xmm, op1: Mem) {
2440        self.emit(
2441            SSE_PADDDRM,
2442            op0.as_operand(),
2443            op1.as_operand(),
2444            &NOREG,
2445            &NOREG,
2446        );
2447    }
2448}
2449
2450/// `SSE_PADDQ`.
2451///
2452/// Supported operand variants:
2453///
2454/// ```text
2455/// +---+----------+
2456/// | # | Operands |
2457/// +---+----------+
2458/// | 1 | Xmm, Mem |
2459/// | 2 | Xmm, Xmm |
2460/// +---+----------+
2461/// ```
2462pub trait SsePaddqEmitter<A, B> {
2463    fn sse_paddq(&mut self, op0: A, op1: B);
2464}
2465
2466impl<'a> SsePaddqEmitter<Xmm, Xmm> for Assembler<'a> {
2467    fn sse_paddq(&mut self, op0: Xmm, op1: Xmm) {
2468        self.emit(
2469            SSE_PADDQRR,
2470            op0.as_operand(),
2471            op1.as_operand(),
2472            &NOREG,
2473            &NOREG,
2474        );
2475    }
2476}
2477
2478impl<'a> SsePaddqEmitter<Xmm, Mem> for Assembler<'a> {
2479    fn sse_paddq(&mut self, op0: Xmm, op1: Mem) {
2480        self.emit(
2481            SSE_PADDQRM,
2482            op0.as_operand(),
2483            op1.as_operand(),
2484            &NOREG,
2485            &NOREG,
2486        );
2487    }
2488}
2489
2490/// `SSE_PADDSB`.
2491///
2492/// Supported operand variants:
2493///
2494/// ```text
2495/// +---+----------+
2496/// | # | Operands |
2497/// +---+----------+
2498/// | 1 | Xmm, Mem |
2499/// | 2 | Xmm, Xmm |
2500/// +---+----------+
2501/// ```
2502pub trait SsePaddsbEmitter<A, B> {
2503    fn sse_paddsb(&mut self, op0: A, op1: B);
2504}
2505
2506impl<'a> SsePaddsbEmitter<Xmm, Xmm> for Assembler<'a> {
2507    fn sse_paddsb(&mut self, op0: Xmm, op1: Xmm) {
2508        self.emit(
2509            SSE_PADDSBRR,
2510            op0.as_operand(),
2511            op1.as_operand(),
2512            &NOREG,
2513            &NOREG,
2514        );
2515    }
2516}
2517
2518impl<'a> SsePaddsbEmitter<Xmm, Mem> for Assembler<'a> {
2519    fn sse_paddsb(&mut self, op0: Xmm, op1: Mem) {
2520        self.emit(
2521            SSE_PADDSBRM,
2522            op0.as_operand(),
2523            op1.as_operand(),
2524            &NOREG,
2525            &NOREG,
2526        );
2527    }
2528}
2529
2530/// `SSE_PADDSW`.
2531///
2532/// Supported operand variants:
2533///
2534/// ```text
2535/// +---+----------+
2536/// | # | Operands |
2537/// +---+----------+
2538/// | 1 | Xmm, Mem |
2539/// | 2 | Xmm, Xmm |
2540/// +---+----------+
2541/// ```
2542pub trait SsePaddswEmitter<A, B> {
2543    fn sse_paddsw(&mut self, op0: A, op1: B);
2544}
2545
2546impl<'a> SsePaddswEmitter<Xmm, Xmm> for Assembler<'a> {
2547    fn sse_paddsw(&mut self, op0: Xmm, op1: Xmm) {
2548        self.emit(
2549            SSE_PADDSWRR,
2550            op0.as_operand(),
2551            op1.as_operand(),
2552            &NOREG,
2553            &NOREG,
2554        );
2555    }
2556}
2557
2558impl<'a> SsePaddswEmitter<Xmm, Mem> for Assembler<'a> {
2559    fn sse_paddsw(&mut self, op0: Xmm, op1: Mem) {
2560        self.emit(
2561            SSE_PADDSWRM,
2562            op0.as_operand(),
2563            op1.as_operand(),
2564            &NOREG,
2565            &NOREG,
2566        );
2567    }
2568}
2569
2570/// `SSE_PADDUSB`.
2571///
2572/// Supported operand variants:
2573///
2574/// ```text
2575/// +---+----------+
2576/// | # | Operands |
2577/// +---+----------+
2578/// | 1 | Xmm, Mem |
2579/// | 2 | Xmm, Xmm |
2580/// +---+----------+
2581/// ```
2582pub trait SsePaddusbEmitter<A, B> {
2583    fn sse_paddusb(&mut self, op0: A, op1: B);
2584}
2585
2586impl<'a> SsePaddusbEmitter<Xmm, Xmm> for Assembler<'a> {
2587    fn sse_paddusb(&mut self, op0: Xmm, op1: Xmm) {
2588        self.emit(
2589            SSE_PADDUSBRR,
2590            op0.as_operand(),
2591            op1.as_operand(),
2592            &NOREG,
2593            &NOREG,
2594        );
2595    }
2596}
2597
2598impl<'a> SsePaddusbEmitter<Xmm, Mem> for Assembler<'a> {
2599    fn sse_paddusb(&mut self, op0: Xmm, op1: Mem) {
2600        self.emit(
2601            SSE_PADDUSBRM,
2602            op0.as_operand(),
2603            op1.as_operand(),
2604            &NOREG,
2605            &NOREG,
2606        );
2607    }
2608}
2609
2610/// `SSE_PADDUSW`.
2611///
2612/// Supported operand variants:
2613///
2614/// ```text
2615/// +---+----------+
2616/// | # | Operands |
2617/// +---+----------+
2618/// | 1 | Xmm, Mem |
2619/// | 2 | Xmm, Xmm |
2620/// +---+----------+
2621/// ```
2622pub trait SsePadduswEmitter<A, B> {
2623    fn sse_paddusw(&mut self, op0: A, op1: B);
2624}
2625
2626impl<'a> SsePadduswEmitter<Xmm, Xmm> for Assembler<'a> {
2627    fn sse_paddusw(&mut self, op0: Xmm, op1: Xmm) {
2628        self.emit(
2629            SSE_PADDUSWRR,
2630            op0.as_operand(),
2631            op1.as_operand(),
2632            &NOREG,
2633            &NOREG,
2634        );
2635    }
2636}
2637
2638impl<'a> SsePadduswEmitter<Xmm, Mem> for Assembler<'a> {
2639    fn sse_paddusw(&mut self, op0: Xmm, op1: Mem) {
2640        self.emit(
2641            SSE_PADDUSWRM,
2642            op0.as_operand(),
2643            op1.as_operand(),
2644            &NOREG,
2645            &NOREG,
2646        );
2647    }
2648}
2649
2650/// `SSE_PADDW`.
2651///
2652/// Supported operand variants:
2653///
2654/// ```text
2655/// +---+----------+
2656/// | # | Operands |
2657/// +---+----------+
2658/// | 1 | Xmm, Mem |
2659/// | 2 | Xmm, Xmm |
2660/// +---+----------+
2661/// ```
2662pub trait SsePaddwEmitter<A, B> {
2663    fn sse_paddw(&mut self, op0: A, op1: B);
2664}
2665
2666impl<'a> SsePaddwEmitter<Xmm, Xmm> for Assembler<'a> {
2667    fn sse_paddw(&mut self, op0: Xmm, op1: Xmm) {
2668        self.emit(
2669            SSE_PADDWRR,
2670            op0.as_operand(),
2671            op1.as_operand(),
2672            &NOREG,
2673            &NOREG,
2674        );
2675    }
2676}
2677
2678impl<'a> SsePaddwEmitter<Xmm, Mem> for Assembler<'a> {
2679    fn sse_paddw(&mut self, op0: Xmm, op1: Mem) {
2680        self.emit(
2681            SSE_PADDWRM,
2682            op0.as_operand(),
2683            op1.as_operand(),
2684            &NOREG,
2685            &NOREG,
2686        );
2687    }
2688}
2689
2690/// `SSE_PAND`.
2691///
2692/// Supported operand variants:
2693///
2694/// ```text
2695/// +---+----------+
2696/// | # | Operands |
2697/// +---+----------+
2698/// | 1 | Xmm, Mem |
2699/// | 2 | Xmm, Xmm |
2700/// +---+----------+
2701/// ```
2702pub trait SsePandEmitter<A, B> {
2703    fn sse_pand(&mut self, op0: A, op1: B);
2704}
2705
2706impl<'a> SsePandEmitter<Xmm, Xmm> for Assembler<'a> {
2707    fn sse_pand(&mut self, op0: Xmm, op1: Xmm) {
2708        self.emit(
2709            SSE_PANDRR,
2710            op0.as_operand(),
2711            op1.as_operand(),
2712            &NOREG,
2713            &NOREG,
2714        );
2715    }
2716}
2717
2718impl<'a> SsePandEmitter<Xmm, Mem> for Assembler<'a> {
2719    fn sse_pand(&mut self, op0: Xmm, op1: Mem) {
2720        self.emit(
2721            SSE_PANDRM,
2722            op0.as_operand(),
2723            op1.as_operand(),
2724            &NOREG,
2725            &NOREG,
2726        );
2727    }
2728}
2729
2730/// `SSE_PANDN`.
2731///
2732/// Supported operand variants:
2733///
2734/// ```text
2735/// +---+----------+
2736/// | # | Operands |
2737/// +---+----------+
2738/// | 1 | Xmm, Mem |
2739/// | 2 | Xmm, Xmm |
2740/// +---+----------+
2741/// ```
2742pub trait SsePandnEmitter<A, B> {
2743    fn sse_pandn(&mut self, op0: A, op1: B);
2744}
2745
2746impl<'a> SsePandnEmitter<Xmm, Xmm> for Assembler<'a> {
2747    fn sse_pandn(&mut self, op0: Xmm, op1: Xmm) {
2748        self.emit(
2749            SSE_PANDNRR,
2750            op0.as_operand(),
2751            op1.as_operand(),
2752            &NOREG,
2753            &NOREG,
2754        );
2755    }
2756}
2757
2758impl<'a> SsePandnEmitter<Xmm, Mem> for Assembler<'a> {
2759    fn sse_pandn(&mut self, op0: Xmm, op1: Mem) {
2760        self.emit(
2761            SSE_PANDNRM,
2762            op0.as_operand(),
2763            op1.as_operand(),
2764            &NOREG,
2765            &NOREG,
2766        );
2767    }
2768}
2769
2770/// `SSE_PAVGB`.
2771///
2772/// Supported operand variants:
2773///
2774/// ```text
2775/// +---+----------+
2776/// | # | Operands |
2777/// +---+----------+
2778/// | 1 | Xmm, Mem |
2779/// | 2 | Xmm, Xmm |
2780/// +---+----------+
2781/// ```
2782pub trait SsePavgbEmitter<A, B> {
2783    fn sse_pavgb(&mut self, op0: A, op1: B);
2784}
2785
2786impl<'a> SsePavgbEmitter<Xmm, Xmm> for Assembler<'a> {
2787    fn sse_pavgb(&mut self, op0: Xmm, op1: Xmm) {
2788        self.emit(
2789            SSE_PAVGBRR,
2790            op0.as_operand(),
2791            op1.as_operand(),
2792            &NOREG,
2793            &NOREG,
2794        );
2795    }
2796}
2797
2798impl<'a> SsePavgbEmitter<Xmm, Mem> for Assembler<'a> {
2799    fn sse_pavgb(&mut self, op0: Xmm, op1: Mem) {
2800        self.emit(
2801            SSE_PAVGBRM,
2802            op0.as_operand(),
2803            op1.as_operand(),
2804            &NOREG,
2805            &NOREG,
2806        );
2807    }
2808}
2809
2810/// `SSE_PAVGW`.
2811///
2812/// Supported operand variants:
2813///
2814/// ```text
2815/// +---+----------+
2816/// | # | Operands |
2817/// +---+----------+
2818/// | 1 | Xmm, Mem |
2819/// | 2 | Xmm, Xmm |
2820/// +---+----------+
2821/// ```
2822pub trait SsePavgwEmitter<A, B> {
2823    fn sse_pavgw(&mut self, op0: A, op1: B);
2824}
2825
2826impl<'a> SsePavgwEmitter<Xmm, Xmm> for Assembler<'a> {
2827    fn sse_pavgw(&mut self, op0: Xmm, op1: Xmm) {
2828        self.emit(
2829            SSE_PAVGWRR,
2830            op0.as_operand(),
2831            op1.as_operand(),
2832            &NOREG,
2833            &NOREG,
2834        );
2835    }
2836}
2837
2838impl<'a> SsePavgwEmitter<Xmm, Mem> for Assembler<'a> {
2839    fn sse_pavgw(&mut self, op0: Xmm, op1: Mem) {
2840        self.emit(
2841            SSE_PAVGWRM,
2842            op0.as_operand(),
2843            op1.as_operand(),
2844            &NOREG,
2845            &NOREG,
2846        );
2847    }
2848}
2849
2850/// `SSE_PCMPEQB`.
2851///
2852/// Supported operand variants:
2853///
2854/// ```text
2855/// +---+----------+
2856/// | # | Operands |
2857/// +---+----------+
2858/// | 1 | Xmm, Mem |
2859/// | 2 | Xmm, Xmm |
2860/// +---+----------+
2861/// ```
2862pub trait SsePcmpeqbEmitter<A, B> {
2863    fn sse_pcmpeqb(&mut self, op0: A, op1: B);
2864}
2865
2866impl<'a> SsePcmpeqbEmitter<Xmm, Xmm> for Assembler<'a> {
2867    fn sse_pcmpeqb(&mut self, op0: Xmm, op1: Xmm) {
2868        self.emit(
2869            SSE_PCMPEQBRR,
2870            op0.as_operand(),
2871            op1.as_operand(),
2872            &NOREG,
2873            &NOREG,
2874        );
2875    }
2876}
2877
2878impl<'a> SsePcmpeqbEmitter<Xmm, Mem> for Assembler<'a> {
2879    fn sse_pcmpeqb(&mut self, op0: Xmm, op1: Mem) {
2880        self.emit(
2881            SSE_PCMPEQBRM,
2882            op0.as_operand(),
2883            op1.as_operand(),
2884            &NOREG,
2885            &NOREG,
2886        );
2887    }
2888}
2889
2890/// `SSE_PCMPEQD`.
2891///
2892/// Supported operand variants:
2893///
2894/// ```text
2895/// +---+----------+
2896/// | # | Operands |
2897/// +---+----------+
2898/// | 1 | Xmm, Mem |
2899/// | 2 | Xmm, Xmm |
2900/// +---+----------+
2901/// ```
2902pub trait SsePcmpeqdEmitter<A, B> {
2903    fn sse_pcmpeqd(&mut self, op0: A, op1: B);
2904}
2905
2906impl<'a> SsePcmpeqdEmitter<Xmm, Xmm> for Assembler<'a> {
2907    fn sse_pcmpeqd(&mut self, op0: Xmm, op1: Xmm) {
2908        self.emit(
2909            SSE_PCMPEQDRR,
2910            op0.as_operand(),
2911            op1.as_operand(),
2912            &NOREG,
2913            &NOREG,
2914        );
2915    }
2916}
2917
2918impl<'a> SsePcmpeqdEmitter<Xmm, Mem> for Assembler<'a> {
2919    fn sse_pcmpeqd(&mut self, op0: Xmm, op1: Mem) {
2920        self.emit(
2921            SSE_PCMPEQDRM,
2922            op0.as_operand(),
2923            op1.as_operand(),
2924            &NOREG,
2925            &NOREG,
2926        );
2927    }
2928}
2929
2930/// `SSE_PCMPEQW`.
2931///
2932/// Supported operand variants:
2933///
2934/// ```text
2935/// +---+----------+
2936/// | # | Operands |
2937/// +---+----------+
2938/// | 1 | Xmm, Mem |
2939/// | 2 | Xmm, Xmm |
2940/// +---+----------+
2941/// ```
2942pub trait SsePcmpeqwEmitter<A, B> {
2943    fn sse_pcmpeqw(&mut self, op0: A, op1: B);
2944}
2945
2946impl<'a> SsePcmpeqwEmitter<Xmm, Xmm> for Assembler<'a> {
2947    fn sse_pcmpeqw(&mut self, op0: Xmm, op1: Xmm) {
2948        self.emit(
2949            SSE_PCMPEQWRR,
2950            op0.as_operand(),
2951            op1.as_operand(),
2952            &NOREG,
2953            &NOREG,
2954        );
2955    }
2956}
2957
2958impl<'a> SsePcmpeqwEmitter<Xmm, Mem> for Assembler<'a> {
2959    fn sse_pcmpeqw(&mut self, op0: Xmm, op1: Mem) {
2960        self.emit(
2961            SSE_PCMPEQWRM,
2962            op0.as_operand(),
2963            op1.as_operand(),
2964            &NOREG,
2965            &NOREG,
2966        );
2967    }
2968}
2969
2970/// `SSE_PCMPGTB`.
2971///
2972/// Supported operand variants:
2973///
2974/// ```text
2975/// +---+----------+
2976/// | # | Operands |
2977/// +---+----------+
2978/// | 1 | Xmm, Mem |
2979/// | 2 | Xmm, Xmm |
2980/// +---+----------+
2981/// ```
2982pub trait SsePcmpgtbEmitter<A, B> {
2983    fn sse_pcmpgtb(&mut self, op0: A, op1: B);
2984}
2985
2986impl<'a> SsePcmpgtbEmitter<Xmm, Xmm> for Assembler<'a> {
2987    fn sse_pcmpgtb(&mut self, op0: Xmm, op1: Xmm) {
2988        self.emit(
2989            SSE_PCMPGTBRR,
2990            op0.as_operand(),
2991            op1.as_operand(),
2992            &NOREG,
2993            &NOREG,
2994        );
2995    }
2996}
2997
2998impl<'a> SsePcmpgtbEmitter<Xmm, Mem> for Assembler<'a> {
2999    fn sse_pcmpgtb(&mut self, op0: Xmm, op1: Mem) {
3000        self.emit(
3001            SSE_PCMPGTBRM,
3002            op0.as_operand(),
3003            op1.as_operand(),
3004            &NOREG,
3005            &NOREG,
3006        );
3007    }
3008}
3009
3010/// `SSE_PCMPGTD`.
3011///
3012/// Supported operand variants:
3013///
3014/// ```text
3015/// +---+----------+
3016/// | # | Operands |
3017/// +---+----------+
3018/// | 1 | Xmm, Mem |
3019/// | 2 | Xmm, Xmm |
3020/// +---+----------+
3021/// ```
3022pub trait SsePcmpgtdEmitter<A, B> {
3023    fn sse_pcmpgtd(&mut self, op0: A, op1: B);
3024}
3025
3026impl<'a> SsePcmpgtdEmitter<Xmm, Xmm> for Assembler<'a> {
3027    fn sse_pcmpgtd(&mut self, op0: Xmm, op1: Xmm) {
3028        self.emit(
3029            SSE_PCMPGTDRR,
3030            op0.as_operand(),
3031            op1.as_operand(),
3032            &NOREG,
3033            &NOREG,
3034        );
3035    }
3036}
3037
3038impl<'a> SsePcmpgtdEmitter<Xmm, Mem> for Assembler<'a> {
3039    fn sse_pcmpgtd(&mut self, op0: Xmm, op1: Mem) {
3040        self.emit(
3041            SSE_PCMPGTDRM,
3042            op0.as_operand(),
3043            op1.as_operand(),
3044            &NOREG,
3045            &NOREG,
3046        );
3047    }
3048}
3049
3050/// `SSE_PCMPGTW`.
3051///
3052/// Supported operand variants:
3053///
3054/// ```text
3055/// +---+----------+
3056/// | # | Operands |
3057/// +---+----------+
3058/// | 1 | Xmm, Mem |
3059/// | 2 | Xmm, Xmm |
3060/// +---+----------+
3061/// ```
3062pub trait SsePcmpgtwEmitter<A, B> {
3063    fn sse_pcmpgtw(&mut self, op0: A, op1: B);
3064}
3065
3066impl<'a> SsePcmpgtwEmitter<Xmm, Xmm> for Assembler<'a> {
3067    fn sse_pcmpgtw(&mut self, op0: Xmm, op1: Xmm) {
3068        self.emit(
3069            SSE_PCMPGTWRR,
3070            op0.as_operand(),
3071            op1.as_operand(),
3072            &NOREG,
3073            &NOREG,
3074        );
3075    }
3076}
3077
3078impl<'a> SsePcmpgtwEmitter<Xmm, Mem> for Assembler<'a> {
3079    fn sse_pcmpgtw(&mut self, op0: Xmm, op1: Mem) {
3080        self.emit(
3081            SSE_PCMPGTWRM,
3082            op0.as_operand(),
3083            op1.as_operand(),
3084            &NOREG,
3085            &NOREG,
3086        );
3087    }
3088}
3089
3090/// `SSE_PEXTRW`.
3091///
3092/// Supported operand variants:
3093///
3094/// ```text
3095/// +---+---------------+
3096/// | # | Operands      |
3097/// +---+---------------+
3098/// | 1 | Gpd, Xmm, Imm |
3099/// | 2 | Mem, Xmm, Imm |
3100/// +---+---------------+
3101/// ```
3102pub trait SsePextrwEmitter<A, B, C> {
3103    fn sse_pextrw(&mut self, op0: A, op1: B, op2: C);
3104}
3105
3106impl<'a> SsePextrwEmitter<Gpd, Xmm, Imm> for Assembler<'a> {
3107    fn sse_pextrw(&mut self, op0: Gpd, op1: Xmm, op2: Imm) {
3108        self.emit(
3109            SSE_PEXTRWRRI,
3110            op0.as_operand(),
3111            op1.as_operand(),
3112            op2.as_operand(),
3113            &NOREG,
3114        );
3115    }
3116}
3117
3118impl<'a> SsePextrwEmitter<Mem, Xmm, Imm> for Assembler<'a> {
3119    fn sse_pextrw(&mut self, op0: Mem, op1: Xmm, op2: Imm) {
3120        self.emit(
3121            SSE_PEXTRWMRI,
3122            op0.as_operand(),
3123            op1.as_operand(),
3124            op2.as_operand(),
3125            &NOREG,
3126        );
3127    }
3128}
3129
3130/// `SSE_PINSRW`.
3131///
3132/// Supported operand variants:
3133///
3134/// ```text
3135/// +---+---------------+
3136/// | # | Operands      |
3137/// +---+---------------+
3138/// | 1 | Xmm, Gpd, Imm |
3139/// | 2 | Xmm, Mem, Imm |
3140/// +---+---------------+
3141/// ```
3142pub trait SsePinsrwEmitter<A, B, C> {
3143    fn sse_pinsrw(&mut self, op0: A, op1: B, op2: C);
3144}
3145
3146impl<'a> SsePinsrwEmitter<Xmm, Gpd, Imm> for Assembler<'a> {
3147    fn sse_pinsrw(&mut self, op0: Xmm, op1: Gpd, op2: Imm) {
3148        self.emit(
3149            SSE_PINSRWRRI,
3150            op0.as_operand(),
3151            op1.as_operand(),
3152            op2.as_operand(),
3153            &NOREG,
3154        );
3155    }
3156}
3157
3158impl<'a> SsePinsrwEmitter<Xmm, Mem, Imm> for Assembler<'a> {
3159    fn sse_pinsrw(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
3160        self.emit(
3161            SSE_PINSRWRMI,
3162            op0.as_operand(),
3163            op1.as_operand(),
3164            op2.as_operand(),
3165            &NOREG,
3166        );
3167    }
3168}
3169
3170/// `SSE_PMADDWD`.
3171///
3172/// Supported operand variants:
3173///
3174/// ```text
3175/// +---+----------+
3176/// | # | Operands |
3177/// +---+----------+
3178/// | 1 | Xmm, Mem |
3179/// | 2 | Xmm, Xmm |
3180/// +---+----------+
3181/// ```
3182pub trait SsePmaddwdEmitter<A, B> {
3183    fn sse_pmaddwd(&mut self, op0: A, op1: B);
3184}
3185
3186impl<'a> SsePmaddwdEmitter<Xmm, Xmm> for Assembler<'a> {
3187    fn sse_pmaddwd(&mut self, op0: Xmm, op1: Xmm) {
3188        self.emit(
3189            SSE_PMADDWDRR,
3190            op0.as_operand(),
3191            op1.as_operand(),
3192            &NOREG,
3193            &NOREG,
3194        );
3195    }
3196}
3197
3198impl<'a> SsePmaddwdEmitter<Xmm, Mem> for Assembler<'a> {
3199    fn sse_pmaddwd(&mut self, op0: Xmm, op1: Mem) {
3200        self.emit(
3201            SSE_PMADDWDRM,
3202            op0.as_operand(),
3203            op1.as_operand(),
3204            &NOREG,
3205            &NOREG,
3206        );
3207    }
3208}
3209
3210/// `SSE_PMAXSW`.
3211///
3212/// Supported operand variants:
3213///
3214/// ```text
3215/// +---+----------+
3216/// | # | Operands |
3217/// +---+----------+
3218/// | 1 | Xmm, Mem |
3219/// | 2 | Xmm, Xmm |
3220/// +---+----------+
3221/// ```
3222pub trait SsePmaxswEmitter<A, B> {
3223    fn sse_pmaxsw(&mut self, op0: A, op1: B);
3224}
3225
3226impl<'a> SsePmaxswEmitter<Xmm, Xmm> for Assembler<'a> {
3227    fn sse_pmaxsw(&mut self, op0: Xmm, op1: Xmm) {
3228        self.emit(
3229            SSE_PMAXSWRR,
3230            op0.as_operand(),
3231            op1.as_operand(),
3232            &NOREG,
3233            &NOREG,
3234        );
3235    }
3236}
3237
3238impl<'a> SsePmaxswEmitter<Xmm, Mem> for Assembler<'a> {
3239    fn sse_pmaxsw(&mut self, op0: Xmm, op1: Mem) {
3240        self.emit(
3241            SSE_PMAXSWRM,
3242            op0.as_operand(),
3243            op1.as_operand(),
3244            &NOREG,
3245            &NOREG,
3246        );
3247    }
3248}
3249
3250/// `SSE_PMAXUB`.
3251///
3252/// Supported operand variants:
3253///
3254/// ```text
3255/// +---+----------+
3256/// | # | Operands |
3257/// +---+----------+
3258/// | 1 | Xmm, Mem |
3259/// | 2 | Xmm, Xmm |
3260/// +---+----------+
3261/// ```
3262pub trait SsePmaxubEmitter<A, B> {
3263    fn sse_pmaxub(&mut self, op0: A, op1: B);
3264}
3265
3266impl<'a> SsePmaxubEmitter<Xmm, Xmm> for Assembler<'a> {
3267    fn sse_pmaxub(&mut self, op0: Xmm, op1: Xmm) {
3268        self.emit(
3269            SSE_PMAXUBRR,
3270            op0.as_operand(),
3271            op1.as_operand(),
3272            &NOREG,
3273            &NOREG,
3274        );
3275    }
3276}
3277
3278impl<'a> SsePmaxubEmitter<Xmm, Mem> for Assembler<'a> {
3279    fn sse_pmaxub(&mut self, op0: Xmm, op1: Mem) {
3280        self.emit(
3281            SSE_PMAXUBRM,
3282            op0.as_operand(),
3283            op1.as_operand(),
3284            &NOREG,
3285            &NOREG,
3286        );
3287    }
3288}
3289
3290/// `SSE_PMINSW`.
3291///
3292/// Supported operand variants:
3293///
3294/// ```text
3295/// +---+----------+
3296/// | # | Operands |
3297/// +---+----------+
3298/// | 1 | Xmm, Mem |
3299/// | 2 | Xmm, Xmm |
3300/// +---+----------+
3301/// ```
3302pub trait SsePminswEmitter<A, B> {
3303    fn sse_pminsw(&mut self, op0: A, op1: B);
3304}
3305
3306impl<'a> SsePminswEmitter<Xmm, Xmm> for Assembler<'a> {
3307    fn sse_pminsw(&mut self, op0: Xmm, op1: Xmm) {
3308        self.emit(
3309            SSE_PMINSWRR,
3310            op0.as_operand(),
3311            op1.as_operand(),
3312            &NOREG,
3313            &NOREG,
3314        );
3315    }
3316}
3317
3318impl<'a> SsePminswEmitter<Xmm, Mem> for Assembler<'a> {
3319    fn sse_pminsw(&mut self, op0: Xmm, op1: Mem) {
3320        self.emit(
3321            SSE_PMINSWRM,
3322            op0.as_operand(),
3323            op1.as_operand(),
3324            &NOREG,
3325            &NOREG,
3326        );
3327    }
3328}
3329
3330/// `SSE_PMINUB`.
3331///
3332/// Supported operand variants:
3333///
3334/// ```text
3335/// +---+----------+
3336/// | # | Operands |
3337/// +---+----------+
3338/// | 1 | Xmm, Mem |
3339/// | 2 | Xmm, Xmm |
3340/// +---+----------+
3341/// ```
3342pub trait SsePminubEmitter<A, B> {
3343    fn sse_pminub(&mut self, op0: A, op1: B);
3344}
3345
3346impl<'a> SsePminubEmitter<Xmm, Xmm> for Assembler<'a> {
3347    fn sse_pminub(&mut self, op0: Xmm, op1: Xmm) {
3348        self.emit(
3349            SSE_PMINUBRR,
3350            op0.as_operand(),
3351            op1.as_operand(),
3352            &NOREG,
3353            &NOREG,
3354        );
3355    }
3356}
3357
3358impl<'a> SsePminubEmitter<Xmm, Mem> for Assembler<'a> {
3359    fn sse_pminub(&mut self, op0: Xmm, op1: Mem) {
3360        self.emit(
3361            SSE_PMINUBRM,
3362            op0.as_operand(),
3363            op1.as_operand(),
3364            &NOREG,
3365            &NOREG,
3366        );
3367    }
3368}
3369
3370/// `SSE_PMOVMSKB`.
3371///
3372/// Supported operand variants:
3373///
3374/// ```text
3375/// +---+----------+
3376/// | # | Operands |
3377/// +---+----------+
3378/// | 1 | Gpq, Xmm |
3379/// +---+----------+
3380/// ```
3381pub trait SsePmovmskbEmitter<A, B> {
3382    fn sse_pmovmskb(&mut self, op0: A, op1: B);
3383}
3384
3385impl<'a> SsePmovmskbEmitter<Gpq, Xmm> for Assembler<'a> {
3386    fn sse_pmovmskb(&mut self, op0: Gpq, op1: Xmm) {
3387        self.emit(
3388            SSE_PMOVMSKBRR,
3389            op0.as_operand(),
3390            op1.as_operand(),
3391            &NOREG,
3392            &NOREG,
3393        );
3394    }
3395}
3396
3397/// `SSE_PMULHUW`.
3398///
3399/// Supported operand variants:
3400///
3401/// ```text
3402/// +---+----------+
3403/// | # | Operands |
3404/// +---+----------+
3405/// | 1 | Xmm, Mem |
3406/// | 2 | Xmm, Xmm |
3407/// +---+----------+
3408/// ```
3409pub trait SsePmulhuwEmitter<A, B> {
3410    fn sse_pmulhuw(&mut self, op0: A, op1: B);
3411}
3412
3413impl<'a> SsePmulhuwEmitter<Xmm, Xmm> for Assembler<'a> {
3414    fn sse_pmulhuw(&mut self, op0: Xmm, op1: Xmm) {
3415        self.emit(
3416            SSE_PMULHUWRR,
3417            op0.as_operand(),
3418            op1.as_operand(),
3419            &NOREG,
3420            &NOREG,
3421        );
3422    }
3423}
3424
3425impl<'a> SsePmulhuwEmitter<Xmm, Mem> for Assembler<'a> {
3426    fn sse_pmulhuw(&mut self, op0: Xmm, op1: Mem) {
3427        self.emit(
3428            SSE_PMULHUWRM,
3429            op0.as_operand(),
3430            op1.as_operand(),
3431            &NOREG,
3432            &NOREG,
3433        );
3434    }
3435}
3436
3437/// `SSE_PMULHW`.
3438///
3439/// Supported operand variants:
3440///
3441/// ```text
3442/// +---+----------+
3443/// | # | Operands |
3444/// +---+----------+
3445/// | 1 | Xmm, Mem |
3446/// | 2 | Xmm, Xmm |
3447/// +---+----------+
3448/// ```
3449pub trait SsePmulhwEmitter<A, B> {
3450    fn sse_pmulhw(&mut self, op0: A, op1: B);
3451}
3452
3453impl<'a> SsePmulhwEmitter<Xmm, Xmm> for Assembler<'a> {
3454    fn sse_pmulhw(&mut self, op0: Xmm, op1: Xmm) {
3455        self.emit(
3456            SSE_PMULHWRR,
3457            op0.as_operand(),
3458            op1.as_operand(),
3459            &NOREG,
3460            &NOREG,
3461        );
3462    }
3463}
3464
3465impl<'a> SsePmulhwEmitter<Xmm, Mem> for Assembler<'a> {
3466    fn sse_pmulhw(&mut self, op0: Xmm, op1: Mem) {
3467        self.emit(
3468            SSE_PMULHWRM,
3469            op0.as_operand(),
3470            op1.as_operand(),
3471            &NOREG,
3472            &NOREG,
3473        );
3474    }
3475}
3476
3477/// `SSE_PMULLW`.
3478///
3479/// Supported operand variants:
3480///
3481/// ```text
3482/// +---+----------+
3483/// | # | Operands |
3484/// +---+----------+
3485/// | 1 | Xmm, Mem |
3486/// | 2 | Xmm, Xmm |
3487/// +---+----------+
3488/// ```
3489pub trait SsePmullwEmitter<A, B> {
3490    fn sse_pmullw(&mut self, op0: A, op1: B);
3491}
3492
3493impl<'a> SsePmullwEmitter<Xmm, Xmm> for Assembler<'a> {
3494    fn sse_pmullw(&mut self, op0: Xmm, op1: Xmm) {
3495        self.emit(
3496            SSE_PMULLWRR,
3497            op0.as_operand(),
3498            op1.as_operand(),
3499            &NOREG,
3500            &NOREG,
3501        );
3502    }
3503}
3504
3505impl<'a> SsePmullwEmitter<Xmm, Mem> for Assembler<'a> {
3506    fn sse_pmullw(&mut self, op0: Xmm, op1: Mem) {
3507        self.emit(
3508            SSE_PMULLWRM,
3509            op0.as_operand(),
3510            op1.as_operand(),
3511            &NOREG,
3512            &NOREG,
3513        );
3514    }
3515}
3516
3517/// `SSE_PMULUDQ`.
3518///
3519/// Supported operand variants:
3520///
3521/// ```text
3522/// +---+----------+
3523/// | # | Operands |
3524/// +---+----------+
3525/// | 1 | Xmm, Mem |
3526/// | 2 | Xmm, Xmm |
3527/// +---+----------+
3528/// ```
3529pub trait SsePmuludqEmitter<A, B> {
3530    fn sse_pmuludq(&mut self, op0: A, op1: B);
3531}
3532
3533impl<'a> SsePmuludqEmitter<Xmm, Xmm> for Assembler<'a> {
3534    fn sse_pmuludq(&mut self, op0: Xmm, op1: Xmm) {
3535        self.emit(
3536            SSE_PMULUDQRR,
3537            op0.as_operand(),
3538            op1.as_operand(),
3539            &NOREG,
3540            &NOREG,
3541        );
3542    }
3543}
3544
3545impl<'a> SsePmuludqEmitter<Xmm, Mem> for Assembler<'a> {
3546    fn sse_pmuludq(&mut self, op0: Xmm, op1: Mem) {
3547        self.emit(
3548            SSE_PMULUDQRM,
3549            op0.as_operand(),
3550            op1.as_operand(),
3551            &NOREG,
3552            &NOREG,
3553        );
3554    }
3555}
3556
3557/// `SSE_POR`.
3558///
3559/// Supported operand variants:
3560///
3561/// ```text
3562/// +---+----------+
3563/// | # | Operands |
3564/// +---+----------+
3565/// | 1 | Xmm, Mem |
3566/// | 2 | Xmm, Xmm |
3567/// +---+----------+
3568/// ```
3569pub trait SsePorEmitter<A, B> {
3570    fn sse_por(&mut self, op0: A, op1: B);
3571}
3572
3573impl<'a> SsePorEmitter<Xmm, Xmm> for Assembler<'a> {
3574    fn sse_por(&mut self, op0: Xmm, op1: Xmm) {
3575        self.emit(
3576            SSE_PORRR,
3577            op0.as_operand(),
3578            op1.as_operand(),
3579            &NOREG,
3580            &NOREG,
3581        );
3582    }
3583}
3584
3585impl<'a> SsePorEmitter<Xmm, Mem> for Assembler<'a> {
3586    fn sse_por(&mut self, op0: Xmm, op1: Mem) {
3587        self.emit(
3588            SSE_PORRM,
3589            op0.as_operand(),
3590            op1.as_operand(),
3591            &NOREG,
3592            &NOREG,
3593        );
3594    }
3595}
3596
3597/// `SSE_PSADBW`.
3598///
3599/// Supported operand variants:
3600///
3601/// ```text
3602/// +---+----------+
3603/// | # | Operands |
3604/// +---+----------+
3605/// | 1 | Xmm, Mem |
3606/// | 2 | Xmm, Xmm |
3607/// +---+----------+
3608/// ```
3609pub trait SsePsadbwEmitter<A, B> {
3610    fn sse_psadbw(&mut self, op0: A, op1: B);
3611}
3612
3613impl<'a> SsePsadbwEmitter<Xmm, Xmm> for Assembler<'a> {
3614    fn sse_psadbw(&mut self, op0: Xmm, op1: Xmm) {
3615        self.emit(
3616            SSE_PSADBWRR,
3617            op0.as_operand(),
3618            op1.as_operand(),
3619            &NOREG,
3620            &NOREG,
3621        );
3622    }
3623}
3624
3625impl<'a> SsePsadbwEmitter<Xmm, Mem> for Assembler<'a> {
3626    fn sse_psadbw(&mut self, op0: Xmm, op1: Mem) {
3627        self.emit(
3628            SSE_PSADBWRM,
3629            op0.as_operand(),
3630            op1.as_operand(),
3631            &NOREG,
3632            &NOREG,
3633        );
3634    }
3635}
3636
3637/// `SSE_PSHUFD`.
3638///
3639/// Supported operand variants:
3640///
3641/// ```text
3642/// +---+---------------+
3643/// | # | Operands      |
3644/// +---+---------------+
3645/// | 1 | Xmm, Mem, Imm |
3646/// | 2 | Xmm, Xmm, Imm |
3647/// +---+---------------+
3648/// ```
3649pub trait SsePshufdEmitter<A, B, C> {
3650    fn sse_pshufd(&mut self, op0: A, op1: B, op2: C);
3651}
3652
3653impl<'a> SsePshufdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
3654    fn sse_pshufd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
3655        self.emit(
3656            SSE_PSHUFDRRI,
3657            op0.as_operand(),
3658            op1.as_operand(),
3659            op2.as_operand(),
3660            &NOREG,
3661        );
3662    }
3663}
3664
3665impl<'a> SsePshufdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
3666    fn sse_pshufd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
3667        self.emit(
3668            SSE_PSHUFDRMI,
3669            op0.as_operand(),
3670            op1.as_operand(),
3671            op2.as_operand(),
3672            &NOREG,
3673        );
3674    }
3675}
3676
3677/// `SSE_PSHUFHW`.
3678///
3679/// Supported operand variants:
3680///
3681/// ```text
3682/// +---+---------------+
3683/// | # | Operands      |
3684/// +---+---------------+
3685/// | 1 | Xmm, Mem, Imm |
3686/// | 2 | Xmm, Xmm, Imm |
3687/// +---+---------------+
3688/// ```
3689pub trait SsePshufhwEmitter<A, B, C> {
3690    fn sse_pshufhw(&mut self, op0: A, op1: B, op2: C);
3691}
3692
3693impl<'a> SsePshufhwEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
3694    fn sse_pshufhw(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
3695        self.emit(
3696            SSE_PSHUFHWRRI,
3697            op0.as_operand(),
3698            op1.as_operand(),
3699            op2.as_operand(),
3700            &NOREG,
3701        );
3702    }
3703}
3704
3705impl<'a> SsePshufhwEmitter<Xmm, Mem, Imm> for Assembler<'a> {
3706    fn sse_pshufhw(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
3707        self.emit(
3708            SSE_PSHUFHWRMI,
3709            op0.as_operand(),
3710            op1.as_operand(),
3711            op2.as_operand(),
3712            &NOREG,
3713        );
3714    }
3715}
3716
3717/// `SSE_PSHUFLW`.
3718///
3719/// Supported operand variants:
3720///
3721/// ```text
3722/// +---+---------------+
3723/// | # | Operands      |
3724/// +---+---------------+
3725/// | 1 | Xmm, Mem, Imm |
3726/// | 2 | Xmm, Xmm, Imm |
3727/// +---+---------------+
3728/// ```
3729pub trait SsePshuflwEmitter<A, B, C> {
3730    fn sse_pshuflw(&mut self, op0: A, op1: B, op2: C);
3731}
3732
3733impl<'a> SsePshuflwEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
3734    fn sse_pshuflw(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
3735        self.emit(
3736            SSE_PSHUFLWRRI,
3737            op0.as_operand(),
3738            op1.as_operand(),
3739            op2.as_operand(),
3740            &NOREG,
3741        );
3742    }
3743}
3744
3745impl<'a> SsePshuflwEmitter<Xmm, Mem, Imm> for Assembler<'a> {
3746    fn sse_pshuflw(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
3747        self.emit(
3748            SSE_PSHUFLWRMI,
3749            op0.as_operand(),
3750            op1.as_operand(),
3751            op2.as_operand(),
3752            &NOREG,
3753        );
3754    }
3755}
3756
3757/// `SSE_PSLLD`.
3758///
3759/// Supported operand variants:
3760///
3761/// ```text
3762/// +---+----------+
3763/// | # | Operands |
3764/// +---+----------+
3765/// | 1 | Xmm, Imm |
3766/// | 2 | Xmm, Mem |
3767/// | 3 | Xmm, Xmm |
3768/// +---+----------+
3769/// ```
3770pub trait SsePslldEmitter<A, B> {
3771    fn sse_pslld(&mut self, op0: A, op1: B);
3772}
3773
3774impl<'a> SsePslldEmitter<Xmm, Imm> for Assembler<'a> {
3775    fn sse_pslld(&mut self, op0: Xmm, op1: Imm) {
3776        self.emit(
3777            SSE_PSLLDRI,
3778            op0.as_operand(),
3779            op1.as_operand(),
3780            &NOREG,
3781            &NOREG,
3782        );
3783    }
3784}
3785
3786impl<'a> SsePslldEmitter<Xmm, Xmm> for Assembler<'a> {
3787    fn sse_pslld(&mut self, op0: Xmm, op1: Xmm) {
3788        self.emit(
3789            SSE_PSLLDRR,
3790            op0.as_operand(),
3791            op1.as_operand(),
3792            &NOREG,
3793            &NOREG,
3794        );
3795    }
3796}
3797
3798impl<'a> SsePslldEmitter<Xmm, Mem> for Assembler<'a> {
3799    fn sse_pslld(&mut self, op0: Xmm, op1: Mem) {
3800        self.emit(
3801            SSE_PSLLDRM,
3802            op0.as_operand(),
3803            op1.as_operand(),
3804            &NOREG,
3805            &NOREG,
3806        );
3807    }
3808}
3809
3810/// `SSE_PSLLDQ`.
3811///
3812/// Supported operand variants:
3813///
3814/// ```text
3815/// +---+----------+
3816/// | # | Operands |
3817/// +---+----------+
3818/// | 1 | Xmm, Imm |
3819/// +---+----------+
3820/// ```
3821pub trait SsePslldqEmitter<A, B> {
3822    fn sse_pslldq(&mut self, op0: A, op1: B);
3823}
3824
3825impl<'a> SsePslldqEmitter<Xmm, Imm> for Assembler<'a> {
3826    fn sse_pslldq(&mut self, op0: Xmm, op1: Imm) {
3827        self.emit(
3828            SSE_PSLLDQRI,
3829            op0.as_operand(),
3830            op1.as_operand(),
3831            &NOREG,
3832            &NOREG,
3833        );
3834    }
3835}
3836
3837/// `SSE_PSLLQ`.
3838///
3839/// Supported operand variants:
3840///
3841/// ```text
3842/// +---+----------+
3843/// | # | Operands |
3844/// +---+----------+
3845/// | 1 | Xmm, Imm |
3846/// | 2 | Xmm, Mem |
3847/// | 3 | Xmm, Xmm |
3848/// +---+----------+
3849/// ```
3850pub trait SsePsllqEmitter<A, B> {
3851    fn sse_psllq(&mut self, op0: A, op1: B);
3852}
3853
3854impl<'a> SsePsllqEmitter<Xmm, Imm> for Assembler<'a> {
3855    fn sse_psllq(&mut self, op0: Xmm, op1: Imm) {
3856        self.emit(
3857            SSE_PSLLQRI,
3858            op0.as_operand(),
3859            op1.as_operand(),
3860            &NOREG,
3861            &NOREG,
3862        );
3863    }
3864}
3865
3866impl<'a> SsePsllqEmitter<Xmm, Xmm> for Assembler<'a> {
3867    fn sse_psllq(&mut self, op0: Xmm, op1: Xmm) {
3868        self.emit(
3869            SSE_PSLLQRR,
3870            op0.as_operand(),
3871            op1.as_operand(),
3872            &NOREG,
3873            &NOREG,
3874        );
3875    }
3876}
3877
3878impl<'a> SsePsllqEmitter<Xmm, Mem> for Assembler<'a> {
3879    fn sse_psllq(&mut self, op0: Xmm, op1: Mem) {
3880        self.emit(
3881            SSE_PSLLQRM,
3882            op0.as_operand(),
3883            op1.as_operand(),
3884            &NOREG,
3885            &NOREG,
3886        );
3887    }
3888}
3889
3890/// `SSE_PSLLW`.
3891///
3892/// Supported operand variants:
3893///
3894/// ```text
3895/// +---+----------+
3896/// | # | Operands |
3897/// +---+----------+
3898/// | 1 | Xmm, Imm |
3899/// | 2 | Xmm, Mem |
3900/// | 3 | Xmm, Xmm |
3901/// +---+----------+
3902/// ```
3903pub trait SsePsllwEmitter<A, B> {
3904    fn sse_psllw(&mut self, op0: A, op1: B);
3905}
3906
3907impl<'a> SsePsllwEmitter<Xmm, Imm> for Assembler<'a> {
3908    fn sse_psllw(&mut self, op0: Xmm, op1: Imm) {
3909        self.emit(
3910            SSE_PSLLWRI,
3911            op0.as_operand(),
3912            op1.as_operand(),
3913            &NOREG,
3914            &NOREG,
3915        );
3916    }
3917}
3918
3919impl<'a> SsePsllwEmitter<Xmm, Xmm> for Assembler<'a> {
3920    fn sse_psllw(&mut self, op0: Xmm, op1: Xmm) {
3921        self.emit(
3922            SSE_PSLLWRR,
3923            op0.as_operand(),
3924            op1.as_operand(),
3925            &NOREG,
3926            &NOREG,
3927        );
3928    }
3929}
3930
3931impl<'a> SsePsllwEmitter<Xmm, Mem> for Assembler<'a> {
3932    fn sse_psllw(&mut self, op0: Xmm, op1: Mem) {
3933        self.emit(
3934            SSE_PSLLWRM,
3935            op0.as_operand(),
3936            op1.as_operand(),
3937            &NOREG,
3938            &NOREG,
3939        );
3940    }
3941}
3942
3943/// `SSE_PSRAD`.
3944///
3945/// Supported operand variants:
3946///
3947/// ```text
3948/// +---+----------+
3949/// | # | Operands |
3950/// +---+----------+
3951/// | 1 | Xmm, Imm |
3952/// | 2 | Xmm, Mem |
3953/// | 3 | Xmm, Xmm |
3954/// +---+----------+
3955/// ```
3956pub trait SsePsradEmitter<A, B> {
3957    fn sse_psrad(&mut self, op0: A, op1: B);
3958}
3959
3960impl<'a> SsePsradEmitter<Xmm, Imm> for Assembler<'a> {
3961    fn sse_psrad(&mut self, op0: Xmm, op1: Imm) {
3962        self.emit(
3963            SSE_PSRADRI,
3964            op0.as_operand(),
3965            op1.as_operand(),
3966            &NOREG,
3967            &NOREG,
3968        );
3969    }
3970}
3971
3972impl<'a> SsePsradEmitter<Xmm, Xmm> for Assembler<'a> {
3973    fn sse_psrad(&mut self, op0: Xmm, op1: Xmm) {
3974        self.emit(
3975            SSE_PSRADRR,
3976            op0.as_operand(),
3977            op1.as_operand(),
3978            &NOREG,
3979            &NOREG,
3980        );
3981    }
3982}
3983
3984impl<'a> SsePsradEmitter<Xmm, Mem> for Assembler<'a> {
3985    fn sse_psrad(&mut self, op0: Xmm, op1: Mem) {
3986        self.emit(
3987            SSE_PSRADRM,
3988            op0.as_operand(),
3989            op1.as_operand(),
3990            &NOREG,
3991            &NOREG,
3992        );
3993    }
3994}
3995
3996/// `SSE_PSRAW`.
3997///
3998/// Supported operand variants:
3999///
4000/// ```text
4001/// +---+----------+
4002/// | # | Operands |
4003/// +---+----------+
4004/// | 1 | Xmm, Imm |
4005/// | 2 | Xmm, Mem |
4006/// | 3 | Xmm, Xmm |
4007/// +---+----------+
4008/// ```
4009pub trait SsePsrawEmitter<A, B> {
4010    fn sse_psraw(&mut self, op0: A, op1: B);
4011}
4012
4013impl<'a> SsePsrawEmitter<Xmm, Imm> for Assembler<'a> {
4014    fn sse_psraw(&mut self, op0: Xmm, op1: Imm) {
4015        self.emit(
4016            SSE_PSRAWRI,
4017            op0.as_operand(),
4018            op1.as_operand(),
4019            &NOREG,
4020            &NOREG,
4021        );
4022    }
4023}
4024
4025impl<'a> SsePsrawEmitter<Xmm, Xmm> for Assembler<'a> {
4026    fn sse_psraw(&mut self, op0: Xmm, op1: Xmm) {
4027        self.emit(
4028            SSE_PSRAWRR,
4029            op0.as_operand(),
4030            op1.as_operand(),
4031            &NOREG,
4032            &NOREG,
4033        );
4034    }
4035}
4036
4037impl<'a> SsePsrawEmitter<Xmm, Mem> for Assembler<'a> {
4038    fn sse_psraw(&mut self, op0: Xmm, op1: Mem) {
4039        self.emit(
4040            SSE_PSRAWRM,
4041            op0.as_operand(),
4042            op1.as_operand(),
4043            &NOREG,
4044            &NOREG,
4045        );
4046    }
4047}
4048
4049/// `SSE_PSRLD`.
4050///
4051/// Supported operand variants:
4052///
4053/// ```text
4054/// +---+----------+
4055/// | # | Operands |
4056/// +---+----------+
4057/// | 1 | Xmm, Imm |
4058/// | 2 | Xmm, Mem |
4059/// | 3 | Xmm, Xmm |
4060/// +---+----------+
4061/// ```
4062pub trait SsePsrldEmitter<A, B> {
4063    fn sse_psrld(&mut self, op0: A, op1: B);
4064}
4065
4066impl<'a> SsePsrldEmitter<Xmm, Imm> for Assembler<'a> {
4067    fn sse_psrld(&mut self, op0: Xmm, op1: Imm) {
4068        self.emit(
4069            SSE_PSRLDRI,
4070            op0.as_operand(),
4071            op1.as_operand(),
4072            &NOREG,
4073            &NOREG,
4074        );
4075    }
4076}
4077
4078impl<'a> SsePsrldEmitter<Xmm, Xmm> for Assembler<'a> {
4079    fn sse_psrld(&mut self, op0: Xmm, op1: Xmm) {
4080        self.emit(
4081            SSE_PSRLDRR,
4082            op0.as_operand(),
4083            op1.as_operand(),
4084            &NOREG,
4085            &NOREG,
4086        );
4087    }
4088}
4089
4090impl<'a> SsePsrldEmitter<Xmm, Mem> for Assembler<'a> {
4091    fn sse_psrld(&mut self, op0: Xmm, op1: Mem) {
4092        self.emit(
4093            SSE_PSRLDRM,
4094            op0.as_operand(),
4095            op1.as_operand(),
4096            &NOREG,
4097            &NOREG,
4098        );
4099    }
4100}
4101
4102/// `SSE_PSRLDQ`.
4103///
4104/// Supported operand variants:
4105///
4106/// ```text
4107/// +---+----------+
4108/// | # | Operands |
4109/// +---+----------+
4110/// | 1 | Xmm, Imm |
4111/// +---+----------+
4112/// ```
4113pub trait SsePsrldqEmitter<A, B> {
4114    fn sse_psrldq(&mut self, op0: A, op1: B);
4115}
4116
4117impl<'a> SsePsrldqEmitter<Xmm, Imm> for Assembler<'a> {
4118    fn sse_psrldq(&mut self, op0: Xmm, op1: Imm) {
4119        self.emit(
4120            SSE_PSRLDQRI,
4121            op0.as_operand(),
4122            op1.as_operand(),
4123            &NOREG,
4124            &NOREG,
4125        );
4126    }
4127}
4128
4129/// `SSE_PSRLQ`.
4130///
4131/// Supported operand variants:
4132///
4133/// ```text
4134/// +---+----------+
4135/// | # | Operands |
4136/// +---+----------+
4137/// | 1 | Xmm, Imm |
4138/// | 2 | Xmm, Mem |
4139/// | 3 | Xmm, Xmm |
4140/// +---+----------+
4141/// ```
4142pub trait SsePsrlqEmitter<A, B> {
4143    fn sse_psrlq(&mut self, op0: A, op1: B);
4144}
4145
4146impl<'a> SsePsrlqEmitter<Xmm, Imm> for Assembler<'a> {
4147    fn sse_psrlq(&mut self, op0: Xmm, op1: Imm) {
4148        self.emit(
4149            SSE_PSRLQRI,
4150            op0.as_operand(),
4151            op1.as_operand(),
4152            &NOREG,
4153            &NOREG,
4154        );
4155    }
4156}
4157
4158impl<'a> SsePsrlqEmitter<Xmm, Xmm> for Assembler<'a> {
4159    fn sse_psrlq(&mut self, op0: Xmm, op1: Xmm) {
4160        self.emit(
4161            SSE_PSRLQRR,
4162            op0.as_operand(),
4163            op1.as_operand(),
4164            &NOREG,
4165            &NOREG,
4166        );
4167    }
4168}
4169
4170impl<'a> SsePsrlqEmitter<Xmm, Mem> for Assembler<'a> {
4171    fn sse_psrlq(&mut self, op0: Xmm, op1: Mem) {
4172        self.emit(
4173            SSE_PSRLQRM,
4174            op0.as_operand(),
4175            op1.as_operand(),
4176            &NOREG,
4177            &NOREG,
4178        );
4179    }
4180}
4181
4182/// `SSE_PSRLW`.
4183///
4184/// Supported operand variants:
4185///
4186/// ```text
4187/// +---+----------+
4188/// | # | Operands |
4189/// +---+----------+
4190/// | 1 | Xmm, Imm |
4191/// | 2 | Xmm, Mem |
4192/// | 3 | Xmm, Xmm |
4193/// +---+----------+
4194/// ```
4195pub trait SsePsrlwEmitter<A, B> {
4196    fn sse_psrlw(&mut self, op0: A, op1: B);
4197}
4198
4199impl<'a> SsePsrlwEmitter<Xmm, Imm> for Assembler<'a> {
4200    fn sse_psrlw(&mut self, op0: Xmm, op1: Imm) {
4201        self.emit(
4202            SSE_PSRLWRI,
4203            op0.as_operand(),
4204            op1.as_operand(),
4205            &NOREG,
4206            &NOREG,
4207        );
4208    }
4209}
4210
4211impl<'a> SsePsrlwEmitter<Xmm, Xmm> for Assembler<'a> {
4212    fn sse_psrlw(&mut self, op0: Xmm, op1: Xmm) {
4213        self.emit(
4214            SSE_PSRLWRR,
4215            op0.as_operand(),
4216            op1.as_operand(),
4217            &NOREG,
4218            &NOREG,
4219        );
4220    }
4221}
4222
4223impl<'a> SsePsrlwEmitter<Xmm, Mem> for Assembler<'a> {
4224    fn sse_psrlw(&mut self, op0: Xmm, op1: Mem) {
4225        self.emit(
4226            SSE_PSRLWRM,
4227            op0.as_operand(),
4228            op1.as_operand(),
4229            &NOREG,
4230            &NOREG,
4231        );
4232    }
4233}
4234
4235/// `SSE_PSUBB`.
4236///
4237/// Supported operand variants:
4238///
4239/// ```text
4240/// +---+----------+
4241/// | # | Operands |
4242/// +---+----------+
4243/// | 1 | Xmm, Mem |
4244/// | 2 | Xmm, Xmm |
4245/// +---+----------+
4246/// ```
4247pub trait SsePsubbEmitter<A, B> {
4248    fn sse_psubb(&mut self, op0: A, op1: B);
4249}
4250
4251impl<'a> SsePsubbEmitter<Xmm, Xmm> for Assembler<'a> {
4252    fn sse_psubb(&mut self, op0: Xmm, op1: Xmm) {
4253        self.emit(
4254            SSE_PSUBBRR,
4255            op0.as_operand(),
4256            op1.as_operand(),
4257            &NOREG,
4258            &NOREG,
4259        );
4260    }
4261}
4262
4263impl<'a> SsePsubbEmitter<Xmm, Mem> for Assembler<'a> {
4264    fn sse_psubb(&mut self, op0: Xmm, op1: Mem) {
4265        self.emit(
4266            SSE_PSUBBRM,
4267            op0.as_operand(),
4268            op1.as_operand(),
4269            &NOREG,
4270            &NOREG,
4271        );
4272    }
4273}
4274
4275/// `SSE_PSUBD`.
4276///
4277/// Supported operand variants:
4278///
4279/// ```text
4280/// +---+----------+
4281/// | # | Operands |
4282/// +---+----------+
4283/// | 1 | Xmm, Mem |
4284/// | 2 | Xmm, Xmm |
4285/// +---+----------+
4286/// ```
4287pub trait SsePsubdEmitter<A, B> {
4288    fn sse_psubd(&mut self, op0: A, op1: B);
4289}
4290
4291impl<'a> SsePsubdEmitter<Xmm, Xmm> for Assembler<'a> {
4292    fn sse_psubd(&mut self, op0: Xmm, op1: Xmm) {
4293        self.emit(
4294            SSE_PSUBDRR,
4295            op0.as_operand(),
4296            op1.as_operand(),
4297            &NOREG,
4298            &NOREG,
4299        );
4300    }
4301}
4302
4303impl<'a> SsePsubdEmitter<Xmm, Mem> for Assembler<'a> {
4304    fn sse_psubd(&mut self, op0: Xmm, op1: Mem) {
4305        self.emit(
4306            SSE_PSUBDRM,
4307            op0.as_operand(),
4308            op1.as_operand(),
4309            &NOREG,
4310            &NOREG,
4311        );
4312    }
4313}
4314
4315/// `SSE_PSUBQ`.
4316///
4317/// Supported operand variants:
4318///
4319/// ```text
4320/// +---+----------+
4321/// | # | Operands |
4322/// +---+----------+
4323/// | 1 | Xmm, Mem |
4324/// | 2 | Xmm, Xmm |
4325/// +---+----------+
4326/// ```
4327pub trait SsePsubqEmitter<A, B> {
4328    fn sse_psubq(&mut self, op0: A, op1: B);
4329}
4330
4331impl<'a> SsePsubqEmitter<Xmm, Xmm> for Assembler<'a> {
4332    fn sse_psubq(&mut self, op0: Xmm, op1: Xmm) {
4333        self.emit(
4334            SSE_PSUBQRR,
4335            op0.as_operand(),
4336            op1.as_operand(),
4337            &NOREG,
4338            &NOREG,
4339        );
4340    }
4341}
4342
4343impl<'a> SsePsubqEmitter<Xmm, Mem> for Assembler<'a> {
4344    fn sse_psubq(&mut self, op0: Xmm, op1: Mem) {
4345        self.emit(
4346            SSE_PSUBQRM,
4347            op0.as_operand(),
4348            op1.as_operand(),
4349            &NOREG,
4350            &NOREG,
4351        );
4352    }
4353}
4354
4355/// `SSE_PSUBSB`.
4356///
4357/// Supported operand variants:
4358///
4359/// ```text
4360/// +---+----------+
4361/// | # | Operands |
4362/// +---+----------+
4363/// | 1 | Xmm, Mem |
4364/// | 2 | Xmm, Xmm |
4365/// +---+----------+
4366/// ```
4367pub trait SsePsubsbEmitter<A, B> {
4368    fn sse_psubsb(&mut self, op0: A, op1: B);
4369}
4370
4371impl<'a> SsePsubsbEmitter<Xmm, Xmm> for Assembler<'a> {
4372    fn sse_psubsb(&mut self, op0: Xmm, op1: Xmm) {
4373        self.emit(
4374            SSE_PSUBSBRR,
4375            op0.as_operand(),
4376            op1.as_operand(),
4377            &NOREG,
4378            &NOREG,
4379        );
4380    }
4381}
4382
4383impl<'a> SsePsubsbEmitter<Xmm, Mem> for Assembler<'a> {
4384    fn sse_psubsb(&mut self, op0: Xmm, op1: Mem) {
4385        self.emit(
4386            SSE_PSUBSBRM,
4387            op0.as_operand(),
4388            op1.as_operand(),
4389            &NOREG,
4390            &NOREG,
4391        );
4392    }
4393}
4394
4395/// `SSE_PSUBSW`.
4396///
4397/// Supported operand variants:
4398///
4399/// ```text
4400/// +---+----------+
4401/// | # | Operands |
4402/// +---+----------+
4403/// | 1 | Xmm, Mem |
4404/// | 2 | Xmm, Xmm |
4405/// +---+----------+
4406/// ```
4407pub trait SsePsubswEmitter<A, B> {
4408    fn sse_psubsw(&mut self, op0: A, op1: B);
4409}
4410
4411impl<'a> SsePsubswEmitter<Xmm, Xmm> for Assembler<'a> {
4412    fn sse_psubsw(&mut self, op0: Xmm, op1: Xmm) {
4413        self.emit(
4414            SSE_PSUBSWRR,
4415            op0.as_operand(),
4416            op1.as_operand(),
4417            &NOREG,
4418            &NOREG,
4419        );
4420    }
4421}
4422
4423impl<'a> SsePsubswEmitter<Xmm, Mem> for Assembler<'a> {
4424    fn sse_psubsw(&mut self, op0: Xmm, op1: Mem) {
4425        self.emit(
4426            SSE_PSUBSWRM,
4427            op0.as_operand(),
4428            op1.as_operand(),
4429            &NOREG,
4430            &NOREG,
4431        );
4432    }
4433}
4434
4435/// `SSE_PSUBUSB`.
4436///
4437/// Supported operand variants:
4438///
4439/// ```text
4440/// +---+----------+
4441/// | # | Operands |
4442/// +---+----------+
4443/// | 1 | Xmm, Mem |
4444/// | 2 | Xmm, Xmm |
4445/// +---+----------+
4446/// ```
4447pub trait SsePsubusbEmitter<A, B> {
4448    fn sse_psubusb(&mut self, op0: A, op1: B);
4449}
4450
4451impl<'a> SsePsubusbEmitter<Xmm, Xmm> for Assembler<'a> {
4452    fn sse_psubusb(&mut self, op0: Xmm, op1: Xmm) {
4453        self.emit(
4454            SSE_PSUBUSBRR,
4455            op0.as_operand(),
4456            op1.as_operand(),
4457            &NOREG,
4458            &NOREG,
4459        );
4460    }
4461}
4462
4463impl<'a> SsePsubusbEmitter<Xmm, Mem> for Assembler<'a> {
4464    fn sse_psubusb(&mut self, op0: Xmm, op1: Mem) {
4465        self.emit(
4466            SSE_PSUBUSBRM,
4467            op0.as_operand(),
4468            op1.as_operand(),
4469            &NOREG,
4470            &NOREG,
4471        );
4472    }
4473}
4474
4475/// `SSE_PSUBUSW`.
4476///
4477/// Supported operand variants:
4478///
4479/// ```text
4480/// +---+----------+
4481/// | # | Operands |
4482/// +---+----------+
4483/// | 1 | Xmm, Mem |
4484/// | 2 | Xmm, Xmm |
4485/// +---+----------+
4486/// ```
4487pub trait SsePsubuswEmitter<A, B> {
4488    fn sse_psubusw(&mut self, op0: A, op1: B);
4489}
4490
4491impl<'a> SsePsubuswEmitter<Xmm, Xmm> for Assembler<'a> {
4492    fn sse_psubusw(&mut self, op0: Xmm, op1: Xmm) {
4493        self.emit(
4494            SSE_PSUBUSWRR,
4495            op0.as_operand(),
4496            op1.as_operand(),
4497            &NOREG,
4498            &NOREG,
4499        );
4500    }
4501}
4502
4503impl<'a> SsePsubuswEmitter<Xmm, Mem> for Assembler<'a> {
4504    fn sse_psubusw(&mut self, op0: Xmm, op1: Mem) {
4505        self.emit(
4506            SSE_PSUBUSWRM,
4507            op0.as_operand(),
4508            op1.as_operand(),
4509            &NOREG,
4510            &NOREG,
4511        );
4512    }
4513}
4514
4515/// `SSE_PSUBW`.
4516///
4517/// Supported operand variants:
4518///
4519/// ```text
4520/// +---+----------+
4521/// | # | Operands |
4522/// +---+----------+
4523/// | 1 | Xmm, Mem |
4524/// | 2 | Xmm, Xmm |
4525/// +---+----------+
4526/// ```
4527pub trait SsePsubwEmitter<A, B> {
4528    fn sse_psubw(&mut self, op0: A, op1: B);
4529}
4530
4531impl<'a> SsePsubwEmitter<Xmm, Xmm> for Assembler<'a> {
4532    fn sse_psubw(&mut self, op0: Xmm, op1: Xmm) {
4533        self.emit(
4534            SSE_PSUBWRR,
4535            op0.as_operand(),
4536            op1.as_operand(),
4537            &NOREG,
4538            &NOREG,
4539        );
4540    }
4541}
4542
4543impl<'a> SsePsubwEmitter<Xmm, Mem> for Assembler<'a> {
4544    fn sse_psubw(&mut self, op0: Xmm, op1: Mem) {
4545        self.emit(
4546            SSE_PSUBWRM,
4547            op0.as_operand(),
4548            op1.as_operand(),
4549            &NOREG,
4550            &NOREG,
4551        );
4552    }
4553}
4554
4555/// `SSE_PUNPCKHBW`.
4556///
4557/// Supported operand variants:
4558///
4559/// ```text
4560/// +---+----------+
4561/// | # | Operands |
4562/// +---+----------+
4563/// | 1 | Xmm, Mem |
4564/// | 2 | Xmm, Xmm |
4565/// +---+----------+
4566/// ```
4567pub trait SsePunpckhbwEmitter<A, B> {
4568    fn sse_punpckhbw(&mut self, op0: A, op1: B);
4569}
4570
4571impl<'a> SsePunpckhbwEmitter<Xmm, Xmm> for Assembler<'a> {
4572    fn sse_punpckhbw(&mut self, op0: Xmm, op1: Xmm) {
4573        self.emit(
4574            SSE_PUNPCKHBWRR,
4575            op0.as_operand(),
4576            op1.as_operand(),
4577            &NOREG,
4578            &NOREG,
4579        );
4580    }
4581}
4582
4583impl<'a> SsePunpckhbwEmitter<Xmm, Mem> for Assembler<'a> {
4584    fn sse_punpckhbw(&mut self, op0: Xmm, op1: Mem) {
4585        self.emit(
4586            SSE_PUNPCKHBWRM,
4587            op0.as_operand(),
4588            op1.as_operand(),
4589            &NOREG,
4590            &NOREG,
4591        );
4592    }
4593}
4594
4595/// `SSE_PUNPCKHDQ`.
4596///
4597/// Supported operand variants:
4598///
4599/// ```text
4600/// +---+----------+
4601/// | # | Operands |
4602/// +---+----------+
4603/// | 1 | Xmm, Mem |
4604/// | 2 | Xmm, Xmm |
4605/// +---+----------+
4606/// ```
4607pub trait SsePunpckhdqEmitter<A, B> {
4608    fn sse_punpckhdq(&mut self, op0: A, op1: B);
4609}
4610
4611impl<'a> SsePunpckhdqEmitter<Xmm, Xmm> for Assembler<'a> {
4612    fn sse_punpckhdq(&mut self, op0: Xmm, op1: Xmm) {
4613        self.emit(
4614            SSE_PUNPCKHDQRR,
4615            op0.as_operand(),
4616            op1.as_operand(),
4617            &NOREG,
4618            &NOREG,
4619        );
4620    }
4621}
4622
4623impl<'a> SsePunpckhdqEmitter<Xmm, Mem> for Assembler<'a> {
4624    fn sse_punpckhdq(&mut self, op0: Xmm, op1: Mem) {
4625        self.emit(
4626            SSE_PUNPCKHDQRM,
4627            op0.as_operand(),
4628            op1.as_operand(),
4629            &NOREG,
4630            &NOREG,
4631        );
4632    }
4633}
4634
4635/// `SSE_PUNPCKHQDQ`.
4636///
4637/// Supported operand variants:
4638///
4639/// ```text
4640/// +---+----------+
4641/// | # | Operands |
4642/// +---+----------+
4643/// | 1 | Xmm, Mem |
4644/// | 2 | Xmm, Xmm |
4645/// +---+----------+
4646/// ```
4647pub trait SsePunpckhqdqEmitter<A, B> {
4648    fn sse_punpckhqdq(&mut self, op0: A, op1: B);
4649}
4650
4651impl<'a> SsePunpckhqdqEmitter<Xmm, Xmm> for Assembler<'a> {
4652    fn sse_punpckhqdq(&mut self, op0: Xmm, op1: Xmm) {
4653        self.emit(
4654            SSE_PUNPCKHQDQRR,
4655            op0.as_operand(),
4656            op1.as_operand(),
4657            &NOREG,
4658            &NOREG,
4659        );
4660    }
4661}
4662
4663impl<'a> SsePunpckhqdqEmitter<Xmm, Mem> for Assembler<'a> {
4664    fn sse_punpckhqdq(&mut self, op0: Xmm, op1: Mem) {
4665        self.emit(
4666            SSE_PUNPCKHQDQRM,
4667            op0.as_operand(),
4668            op1.as_operand(),
4669            &NOREG,
4670            &NOREG,
4671        );
4672    }
4673}
4674
4675/// `SSE_PUNPCKHWD`.
4676///
4677/// Supported operand variants:
4678///
4679/// ```text
4680/// +---+----------+
4681/// | # | Operands |
4682/// +---+----------+
4683/// | 1 | Xmm, Mem |
4684/// | 2 | Xmm, Xmm |
4685/// +---+----------+
4686/// ```
4687pub trait SsePunpckhwdEmitter<A, B> {
4688    fn sse_punpckhwd(&mut self, op0: A, op1: B);
4689}
4690
4691impl<'a> SsePunpckhwdEmitter<Xmm, Xmm> for Assembler<'a> {
4692    fn sse_punpckhwd(&mut self, op0: Xmm, op1: Xmm) {
4693        self.emit(
4694            SSE_PUNPCKHWDRR,
4695            op0.as_operand(),
4696            op1.as_operand(),
4697            &NOREG,
4698            &NOREG,
4699        );
4700    }
4701}
4702
4703impl<'a> SsePunpckhwdEmitter<Xmm, Mem> for Assembler<'a> {
4704    fn sse_punpckhwd(&mut self, op0: Xmm, op1: Mem) {
4705        self.emit(
4706            SSE_PUNPCKHWDRM,
4707            op0.as_operand(),
4708            op1.as_operand(),
4709            &NOREG,
4710            &NOREG,
4711        );
4712    }
4713}
4714
4715/// `SSE_PUNPCKLBW`.
4716///
4717/// Supported operand variants:
4718///
4719/// ```text
4720/// +---+----------+
4721/// | # | Operands |
4722/// +---+----------+
4723/// | 1 | Xmm, Mem |
4724/// | 2 | Xmm, Xmm |
4725/// +---+----------+
4726/// ```
4727pub trait SsePunpcklbwEmitter<A, B> {
4728    fn sse_punpcklbw(&mut self, op0: A, op1: B);
4729}
4730
4731impl<'a> SsePunpcklbwEmitter<Xmm, Xmm> for Assembler<'a> {
4732    fn sse_punpcklbw(&mut self, op0: Xmm, op1: Xmm) {
4733        self.emit(
4734            SSE_PUNPCKLBWRR,
4735            op0.as_operand(),
4736            op1.as_operand(),
4737            &NOREG,
4738            &NOREG,
4739        );
4740    }
4741}
4742
4743impl<'a> SsePunpcklbwEmitter<Xmm, Mem> for Assembler<'a> {
4744    fn sse_punpcklbw(&mut self, op0: Xmm, op1: Mem) {
4745        self.emit(
4746            SSE_PUNPCKLBWRM,
4747            op0.as_operand(),
4748            op1.as_operand(),
4749            &NOREG,
4750            &NOREG,
4751        );
4752    }
4753}
4754
4755/// `SSE_PUNPCKLDQ`.
4756///
4757/// Supported operand variants:
4758///
4759/// ```text
4760/// +---+----------+
4761/// | # | Operands |
4762/// +---+----------+
4763/// | 1 | Xmm, Mem |
4764/// | 2 | Xmm, Xmm |
4765/// +---+----------+
4766/// ```
4767pub trait SsePunpckldqEmitter<A, B> {
4768    fn sse_punpckldq(&mut self, op0: A, op1: B);
4769}
4770
4771impl<'a> SsePunpckldqEmitter<Xmm, Xmm> for Assembler<'a> {
4772    fn sse_punpckldq(&mut self, op0: Xmm, op1: Xmm) {
4773        self.emit(
4774            SSE_PUNPCKLDQRR,
4775            op0.as_operand(),
4776            op1.as_operand(),
4777            &NOREG,
4778            &NOREG,
4779        );
4780    }
4781}
4782
4783impl<'a> SsePunpckldqEmitter<Xmm, Mem> for Assembler<'a> {
4784    fn sse_punpckldq(&mut self, op0: Xmm, op1: Mem) {
4785        self.emit(
4786            SSE_PUNPCKLDQRM,
4787            op0.as_operand(),
4788            op1.as_operand(),
4789            &NOREG,
4790            &NOREG,
4791        );
4792    }
4793}
4794
4795/// `SSE_PUNPCKLQDQ`.
4796///
4797/// Supported operand variants:
4798///
4799/// ```text
4800/// +---+----------+
4801/// | # | Operands |
4802/// +---+----------+
4803/// | 1 | Xmm, Mem |
4804/// | 2 | Xmm, Xmm |
4805/// +---+----------+
4806/// ```
4807pub trait SsePunpcklqdqEmitter<A, B> {
4808    fn sse_punpcklqdq(&mut self, op0: A, op1: B);
4809}
4810
4811impl<'a> SsePunpcklqdqEmitter<Xmm, Xmm> for Assembler<'a> {
4812    fn sse_punpcklqdq(&mut self, op0: Xmm, op1: Xmm) {
4813        self.emit(
4814            SSE_PUNPCKLQDQRR,
4815            op0.as_operand(),
4816            op1.as_operand(),
4817            &NOREG,
4818            &NOREG,
4819        );
4820    }
4821}
4822
4823impl<'a> SsePunpcklqdqEmitter<Xmm, Mem> for Assembler<'a> {
4824    fn sse_punpcklqdq(&mut self, op0: Xmm, op1: Mem) {
4825        self.emit(
4826            SSE_PUNPCKLQDQRM,
4827            op0.as_operand(),
4828            op1.as_operand(),
4829            &NOREG,
4830            &NOREG,
4831        );
4832    }
4833}
4834
4835/// `SSE_PUNPCKLWD`.
4836///
4837/// Supported operand variants:
4838///
4839/// ```text
4840/// +---+----------+
4841/// | # | Operands |
4842/// +---+----------+
4843/// | 1 | Xmm, Mem |
4844/// | 2 | Xmm, Xmm |
4845/// +---+----------+
4846/// ```
4847pub trait SsePunpcklwdEmitter<A, B> {
4848    fn sse_punpcklwd(&mut self, op0: A, op1: B);
4849}
4850
4851impl<'a> SsePunpcklwdEmitter<Xmm, Xmm> for Assembler<'a> {
4852    fn sse_punpcklwd(&mut self, op0: Xmm, op1: Xmm) {
4853        self.emit(
4854            SSE_PUNPCKLWDRR,
4855            op0.as_operand(),
4856            op1.as_operand(),
4857            &NOREG,
4858            &NOREG,
4859        );
4860    }
4861}
4862
4863impl<'a> SsePunpcklwdEmitter<Xmm, Mem> for Assembler<'a> {
4864    fn sse_punpcklwd(&mut self, op0: Xmm, op1: Mem) {
4865        self.emit(
4866            SSE_PUNPCKLWDRM,
4867            op0.as_operand(),
4868            op1.as_operand(),
4869            &NOREG,
4870            &NOREG,
4871        );
4872    }
4873}
4874
4875/// `SSE_PXOR`.
4876///
4877/// Supported operand variants:
4878///
4879/// ```text
4880/// +---+----------+
4881/// | # | Operands |
4882/// +---+----------+
4883/// | 1 | Xmm, Mem |
4884/// | 2 | Xmm, Xmm |
4885/// +---+----------+
4886/// ```
4887pub trait SsePxorEmitter<A, B> {
4888    fn sse_pxor(&mut self, op0: A, op1: B);
4889}
4890
4891impl<'a> SsePxorEmitter<Xmm, Xmm> for Assembler<'a> {
4892    fn sse_pxor(&mut self, op0: Xmm, op1: Xmm) {
4893        self.emit(
4894            SSE_PXORRR,
4895            op0.as_operand(),
4896            op1.as_operand(),
4897            &NOREG,
4898            &NOREG,
4899        );
4900    }
4901}
4902
4903impl<'a> SsePxorEmitter<Xmm, Mem> for Assembler<'a> {
4904    fn sse_pxor(&mut self, op0: Xmm, op1: Mem) {
4905        self.emit(
4906            SSE_PXORRM,
4907            op0.as_operand(),
4908            op1.as_operand(),
4909            &NOREG,
4910            &NOREG,
4911        );
4912    }
4913}
4914
4915/// `SSE_SHUFPD`.
4916///
4917/// Supported operand variants:
4918///
4919/// ```text
4920/// +---+---------------+
4921/// | # | Operands      |
4922/// +---+---------------+
4923/// | 1 | Xmm, Mem, Imm |
4924/// | 2 | Xmm, Xmm, Imm |
4925/// +---+---------------+
4926/// ```
4927pub trait SseShufpdEmitter<A, B, C> {
4928    fn sse_shufpd(&mut self, op0: A, op1: B, op2: C);
4929}
4930
4931impl<'a> SseShufpdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
4932    fn sse_shufpd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
4933        self.emit(
4934            SSE_SHUFPDRRI,
4935            op0.as_operand(),
4936            op1.as_operand(),
4937            op2.as_operand(),
4938            &NOREG,
4939        );
4940    }
4941}
4942
4943impl<'a> SseShufpdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
4944    fn sse_shufpd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
4945        self.emit(
4946            SSE_SHUFPDRMI,
4947            op0.as_operand(),
4948            op1.as_operand(),
4949            op2.as_operand(),
4950            &NOREG,
4951        );
4952    }
4953}
4954
4955/// `SSE_SQRTPD`.
4956///
4957/// Supported operand variants:
4958///
4959/// ```text
4960/// +---+----------+
4961/// | # | Operands |
4962/// +---+----------+
4963/// | 1 | Xmm, Mem |
4964/// | 2 | Xmm, Xmm |
4965/// +---+----------+
4966/// ```
4967pub trait SseSqrtpdEmitter<A, B> {
4968    fn sse_sqrtpd(&mut self, op0: A, op1: B);
4969}
4970
4971impl<'a> SseSqrtpdEmitter<Xmm, Xmm> for Assembler<'a> {
4972    fn sse_sqrtpd(&mut self, op0: Xmm, op1: Xmm) {
4973        self.emit(
4974            SSE_SQRTPDRR,
4975            op0.as_operand(),
4976            op1.as_operand(),
4977            &NOREG,
4978            &NOREG,
4979        );
4980    }
4981}
4982
4983impl<'a> SseSqrtpdEmitter<Xmm, Mem> for Assembler<'a> {
4984    fn sse_sqrtpd(&mut self, op0: Xmm, op1: Mem) {
4985        self.emit(
4986            SSE_SQRTPDRM,
4987            op0.as_operand(),
4988            op1.as_operand(),
4989            &NOREG,
4990            &NOREG,
4991        );
4992    }
4993}
4994
4995/// `SSE_SQRTSD`.
4996///
4997/// Supported operand variants:
4998///
4999/// ```text
5000/// +---+----------+
5001/// | # | Operands |
5002/// +---+----------+
5003/// | 1 | Xmm, Mem |
5004/// | 2 | Xmm, Xmm |
5005/// +---+----------+
5006/// ```
5007pub trait SseSqrtsdEmitter<A, B> {
5008    fn sse_sqrtsd(&mut self, op0: A, op1: B);
5009}
5010
5011impl<'a> SseSqrtsdEmitter<Xmm, Xmm> for Assembler<'a> {
5012    fn sse_sqrtsd(&mut self, op0: Xmm, op1: Xmm) {
5013        self.emit(
5014            SSE_SQRTSDRR,
5015            op0.as_operand(),
5016            op1.as_operand(),
5017            &NOREG,
5018            &NOREG,
5019        );
5020    }
5021}
5022
5023impl<'a> SseSqrtsdEmitter<Xmm, Mem> for Assembler<'a> {
5024    fn sse_sqrtsd(&mut self, op0: Xmm, op1: Mem) {
5025        self.emit(
5026            SSE_SQRTSDRM,
5027            op0.as_operand(),
5028            op1.as_operand(),
5029            &NOREG,
5030            &NOREG,
5031        );
5032    }
5033}
5034
5035/// `SSE_SUBPD`.
5036///
5037/// Supported operand variants:
5038///
5039/// ```text
5040/// +---+----------+
5041/// | # | Operands |
5042/// +---+----------+
5043/// | 1 | Xmm, Mem |
5044/// | 2 | Xmm, Xmm |
5045/// +---+----------+
5046/// ```
5047pub trait SseSubpdEmitter<A, B> {
5048    fn sse_subpd(&mut self, op0: A, op1: B);
5049}
5050
5051impl<'a> SseSubpdEmitter<Xmm, Xmm> for Assembler<'a> {
5052    fn sse_subpd(&mut self, op0: Xmm, op1: Xmm) {
5053        self.emit(
5054            SSE_SUBPDRR,
5055            op0.as_operand(),
5056            op1.as_operand(),
5057            &NOREG,
5058            &NOREG,
5059        );
5060    }
5061}
5062
5063impl<'a> SseSubpdEmitter<Xmm, Mem> for Assembler<'a> {
5064    fn sse_subpd(&mut self, op0: Xmm, op1: Mem) {
5065        self.emit(
5066            SSE_SUBPDRM,
5067            op0.as_operand(),
5068            op1.as_operand(),
5069            &NOREG,
5070            &NOREG,
5071        );
5072    }
5073}
5074
5075/// `SSE_SUBSD`.
5076///
5077/// Supported operand variants:
5078///
5079/// ```text
5080/// +---+----------+
5081/// | # | Operands |
5082/// +---+----------+
5083/// | 1 | Xmm, Mem |
5084/// | 2 | Xmm, Xmm |
5085/// +---+----------+
5086/// ```
5087pub trait SseSubsdEmitter<A, B> {
5088    fn sse_subsd(&mut self, op0: A, op1: B);
5089}
5090
5091impl<'a> SseSubsdEmitter<Xmm, Xmm> for Assembler<'a> {
5092    fn sse_subsd(&mut self, op0: Xmm, op1: Xmm) {
5093        self.emit(
5094            SSE_SUBSDRR,
5095            op0.as_operand(),
5096            op1.as_operand(),
5097            &NOREG,
5098            &NOREG,
5099        );
5100    }
5101}
5102
5103impl<'a> SseSubsdEmitter<Xmm, Mem> for Assembler<'a> {
5104    fn sse_subsd(&mut self, op0: Xmm, op1: Mem) {
5105        self.emit(
5106            SSE_SUBSDRM,
5107            op0.as_operand(),
5108            op1.as_operand(),
5109            &NOREG,
5110            &NOREG,
5111        );
5112    }
5113}
5114
5115/// `SSE_UCOMISD`.
5116///
5117/// Supported operand variants:
5118///
5119/// ```text
5120/// +---+----------+
5121/// | # | Operands |
5122/// +---+----------+
5123/// | 1 | Xmm, Mem |
5124/// | 2 | Xmm, Xmm |
5125/// +---+----------+
5126/// ```
5127pub trait SseUcomisdEmitter<A, B> {
5128    fn sse_ucomisd(&mut self, op0: A, op1: B);
5129}
5130
5131impl<'a> SseUcomisdEmitter<Xmm, Xmm> for Assembler<'a> {
5132    fn sse_ucomisd(&mut self, op0: Xmm, op1: Xmm) {
5133        self.emit(
5134            SSE_UCOMISDRR,
5135            op0.as_operand(),
5136            op1.as_operand(),
5137            &NOREG,
5138            &NOREG,
5139        );
5140    }
5141}
5142
5143impl<'a> SseUcomisdEmitter<Xmm, Mem> for Assembler<'a> {
5144    fn sse_ucomisd(&mut self, op0: Xmm, op1: Mem) {
5145        self.emit(
5146            SSE_UCOMISDRM,
5147            op0.as_operand(),
5148            op1.as_operand(),
5149            &NOREG,
5150            &NOREG,
5151        );
5152    }
5153}
5154
5155/// `SSE_UNPCKHPD`.
5156///
5157/// Supported operand variants:
5158///
5159/// ```text
5160/// +---+----------+
5161/// | # | Operands |
5162/// +---+----------+
5163/// | 1 | Xmm, Mem |
5164/// | 2 | Xmm, Xmm |
5165/// +---+----------+
5166/// ```
5167pub trait SseUnpckhpdEmitter<A, B> {
5168    fn sse_unpckhpd(&mut self, op0: A, op1: B);
5169}
5170
5171impl<'a> SseUnpckhpdEmitter<Xmm, Xmm> for Assembler<'a> {
5172    fn sse_unpckhpd(&mut self, op0: Xmm, op1: Xmm) {
5173        self.emit(
5174            SSE_UNPCKHPDRR,
5175            op0.as_operand(),
5176            op1.as_operand(),
5177            &NOREG,
5178            &NOREG,
5179        );
5180    }
5181}
5182
5183impl<'a> SseUnpckhpdEmitter<Xmm, Mem> for Assembler<'a> {
5184    fn sse_unpckhpd(&mut self, op0: Xmm, op1: Mem) {
5185        self.emit(
5186            SSE_UNPCKHPDRM,
5187            op0.as_operand(),
5188            op1.as_operand(),
5189            &NOREG,
5190            &NOREG,
5191        );
5192    }
5193}
5194
5195/// `SSE_UNPCKLPD`.
5196///
5197/// Supported operand variants:
5198///
5199/// ```text
5200/// +---+----------+
5201/// | # | Operands |
5202/// +---+----------+
5203/// | 1 | Xmm, Mem |
5204/// | 2 | Xmm, Xmm |
5205/// +---+----------+
5206/// ```
5207pub trait SseUnpcklpdEmitter<A, B> {
5208    fn sse_unpcklpd(&mut self, op0: A, op1: B);
5209}
5210
5211impl<'a> SseUnpcklpdEmitter<Xmm, Xmm> for Assembler<'a> {
5212    fn sse_unpcklpd(&mut self, op0: Xmm, op1: Xmm) {
5213        self.emit(
5214            SSE_UNPCKLPDRR,
5215            op0.as_operand(),
5216            op1.as_operand(),
5217            &NOREG,
5218            &NOREG,
5219        );
5220    }
5221}
5222
5223impl<'a> SseUnpcklpdEmitter<Xmm, Mem> for Assembler<'a> {
5224    fn sse_unpcklpd(&mut self, op0: Xmm, op1: Mem) {
5225        self.emit(
5226            SSE_UNPCKLPDRM,
5227            op0.as_operand(),
5228            op1.as_operand(),
5229            &NOREG,
5230            &NOREG,
5231        );
5232    }
5233}
5234
5235/// `SSE_XORPD`.
5236///
5237/// Supported operand variants:
5238///
5239/// ```text
5240/// +---+----------+
5241/// | # | Operands |
5242/// +---+----------+
5243/// | 1 | Xmm, Mem |
5244/// | 2 | Xmm, Xmm |
5245/// +---+----------+
5246/// ```
5247pub trait SseXorpdEmitter<A, B> {
5248    fn sse_xorpd(&mut self, op0: A, op1: B);
5249}
5250
5251impl<'a> SseXorpdEmitter<Xmm, Xmm> for Assembler<'a> {
5252    fn sse_xorpd(&mut self, op0: Xmm, op1: Xmm) {
5253        self.emit(
5254            SSE_XORPDRR,
5255            op0.as_operand(),
5256            op1.as_operand(),
5257            &NOREG,
5258            &NOREG,
5259        );
5260    }
5261}
5262
5263impl<'a> SseXorpdEmitter<Xmm, Mem> for Assembler<'a> {
5264    fn sse_xorpd(&mut self, op0: Xmm, op1: Mem) {
5265        self.emit(
5266            SSE_XORPDRM,
5267            op0.as_operand(),
5268            op1.as_operand(),
5269            &NOREG,
5270            &NOREG,
5271        );
5272    }
5273}
5274
5275impl<'a> Assembler<'a> {
5276    /// `LFENCE`.
5277    ///
5278    /// Supported operand variants:
5279    ///
5280    /// ```text
5281    /// +---+----------+
5282    /// | # | Operands |
5283    /// +---+----------+
5284    /// | 1 | (none)   |
5285    /// +---+----------+
5286    /// ```
5287    #[inline]
5288    pub fn lfence(&mut self)
5289    where
5290        Assembler<'a>: LfenceEmitter,
5291    {
5292        <Self as LfenceEmitter>::lfence(self);
5293    }
5294    /// `MFENCE`.
5295    ///
5296    /// Supported operand variants:
5297    ///
5298    /// ```text
5299    /// +---+----------+
5300    /// | # | Operands |
5301    /// +---+----------+
5302    /// | 1 | (none)   |
5303    /// +---+----------+
5304    /// ```
5305    #[inline]
5306    pub fn mfence(&mut self)
5307    where
5308        Assembler<'a>: MfenceEmitter,
5309    {
5310        <Self as MfenceEmitter>::mfence(self);
5311    }
5312    /// `MMX_CVTPD2PI`.
5313    ///
5314    /// Supported operand variants:
5315    ///
5316    /// ```text
5317    /// +---+----------+
5318    /// | # | Operands |
5319    /// +---+----------+
5320    /// | 1 | Mm, Mem  |
5321    /// | 2 | Mm, Xmm  |
5322    /// +---+----------+
5323    /// ```
5324    #[inline]
5325    pub fn mmx_cvtpd2pi<A, B>(&mut self, op0: A, op1: B)
5326    where
5327        Assembler<'a>: MmxCvtpd2piEmitter<A, B>,
5328    {
5329        <Self as MmxCvtpd2piEmitter<A, B>>::mmx_cvtpd2pi(self, op0, op1);
5330    }
5331    /// `MMX_CVTPI2PD`.
5332    ///
5333    /// Supported operand variants:
5334    ///
5335    /// ```text
5336    /// +---+----------+
5337    /// | # | Operands |
5338    /// +---+----------+
5339    /// | 1 | Xmm, Mem |
5340    /// | 2 | Xmm, Mm  |
5341    /// +---+----------+
5342    /// ```
5343    #[inline]
5344    pub fn mmx_cvtpi2pd<A, B>(&mut self, op0: A, op1: B)
5345    where
5346        Assembler<'a>: MmxCvtpi2pdEmitter<A, B>,
5347    {
5348        <Self as MmxCvtpi2pdEmitter<A, B>>::mmx_cvtpi2pd(self, op0, op1);
5349    }
5350    /// `MMX_CVTPI2PS`.
5351    ///
5352    /// Supported operand variants:
5353    ///
5354    /// ```text
5355    /// +---+----------+
5356    /// | # | Operands |
5357    /// +---+----------+
5358    /// | 1 | Xmm, Mem |
5359    /// | 2 | Xmm, Mm  |
5360    /// +---+----------+
5361    /// ```
5362    #[inline]
5363    pub fn mmx_cvtpi2ps<A, B>(&mut self, op0: A, op1: B)
5364    where
5365        Assembler<'a>: MmxCvtpi2psEmitter<A, B>,
5366    {
5367        <Self as MmxCvtpi2psEmitter<A, B>>::mmx_cvtpi2ps(self, op0, op1);
5368    }
5369    /// `MMX_CVTPS2PI`.
5370    ///
5371    /// Supported operand variants:
5372    ///
5373    /// ```text
5374    /// +---+----------+
5375    /// | # | Operands |
5376    /// +---+----------+
5377    /// | 1 | Mm, Mem  |
5378    /// | 2 | Mm, Xmm  |
5379    /// +---+----------+
5380    /// ```
5381    #[inline]
5382    pub fn mmx_cvtps2pi<A, B>(&mut self, op0: A, op1: B)
5383    where
5384        Assembler<'a>: MmxCvtps2piEmitter<A, B>,
5385    {
5386        <Self as MmxCvtps2piEmitter<A, B>>::mmx_cvtps2pi(self, op0, op1);
5387    }
5388    /// `MMX_CVTTPD2PI`.
5389    ///
5390    /// Supported operand variants:
5391    ///
5392    /// ```text
5393    /// +---+----------+
5394    /// | # | Operands |
5395    /// +---+----------+
5396    /// | 1 | Mm, Mem  |
5397    /// | 2 | Mm, Xmm  |
5398    /// +---+----------+
5399    /// ```
5400    #[inline]
5401    pub fn mmx_cvttpd2pi<A, B>(&mut self, op0: A, op1: B)
5402    where
5403        Assembler<'a>: MmxCvttpd2piEmitter<A, B>,
5404    {
5405        <Self as MmxCvttpd2piEmitter<A, B>>::mmx_cvttpd2pi(self, op0, op1);
5406    }
5407    /// `MMX_CVTTPS2PI`.
5408    ///
5409    /// Supported operand variants:
5410    ///
5411    /// ```text
5412    /// +---+----------+
5413    /// | # | Operands |
5414    /// +---+----------+
5415    /// | 1 | Mm, Mem  |
5416    /// | 2 | Mm, Xmm  |
5417    /// +---+----------+
5418    /// ```
5419    #[inline]
5420    pub fn mmx_cvttps2pi<A, B>(&mut self, op0: A, op1: B)
5421    where
5422        Assembler<'a>: MmxCvttps2piEmitter<A, B>,
5423    {
5424        <Self as MmxCvttps2piEmitter<A, B>>::mmx_cvttps2pi(self, op0, op1);
5425    }
5426    /// `MOVNTI`.
5427    ///
5428    /// Supported operand variants:
5429    ///
5430    /// ```text
5431    /// +---+----------+
5432    /// | # | Operands |
5433    /// +---+----------+
5434    /// | 1 | Mem, Gpd |
5435    /// | 2 | Mem, Gpq |
5436    /// +---+----------+
5437    /// ```
5438    #[inline]
5439    pub fn movnti<A, B>(&mut self, op0: A, op1: B)
5440    where
5441        Assembler<'a>: MovntiEmitter<A, B>,
5442    {
5443        <Self as MovntiEmitter<A, B>>::movnti(self, op0, op1);
5444    }
5445    /// `SSE_ADDPD`.
5446    ///
5447    /// Supported operand variants:
5448    ///
5449    /// ```text
5450    /// +---+----------+
5451    /// | # | Operands |
5452    /// +---+----------+
5453    /// | 1 | Xmm, Mem |
5454    /// | 2 | Xmm, Xmm |
5455    /// +---+----------+
5456    /// ```
5457    #[inline]
5458    pub fn sse_addpd<A, B>(&mut self, op0: A, op1: B)
5459    where
5460        Assembler<'a>: SseAddpdEmitter<A, B>,
5461    {
5462        <Self as SseAddpdEmitter<A, B>>::sse_addpd(self, op0, op1);
5463    }
5464    /// `SSE_ADDSD`.
5465    ///
5466    /// Supported operand variants:
5467    ///
5468    /// ```text
5469    /// +---+----------+
5470    /// | # | Operands |
5471    /// +---+----------+
5472    /// | 1 | Xmm, Mem |
5473    /// | 2 | Xmm, Xmm |
5474    /// +---+----------+
5475    /// ```
5476    #[inline]
5477    pub fn sse_addsd<A, B>(&mut self, op0: A, op1: B)
5478    where
5479        Assembler<'a>: SseAddsdEmitter<A, B>,
5480    {
5481        <Self as SseAddsdEmitter<A, B>>::sse_addsd(self, op0, op1);
5482    }
5483    /// `SSE_ANDNPD`.
5484    ///
5485    /// Supported operand variants:
5486    ///
5487    /// ```text
5488    /// +---+----------+
5489    /// | # | Operands |
5490    /// +---+----------+
5491    /// | 1 | Xmm, Mem |
5492    /// | 2 | Xmm, Xmm |
5493    /// +---+----------+
5494    /// ```
5495    #[inline]
5496    pub fn sse_andnpd<A, B>(&mut self, op0: A, op1: B)
5497    where
5498        Assembler<'a>: SseAndnpdEmitter<A, B>,
5499    {
5500        <Self as SseAndnpdEmitter<A, B>>::sse_andnpd(self, op0, op1);
5501    }
5502    /// `SSE_ANDPD`.
5503    ///
5504    /// Supported operand variants:
5505    ///
5506    /// ```text
5507    /// +---+----------+
5508    /// | # | Operands |
5509    /// +---+----------+
5510    /// | 1 | Xmm, Mem |
5511    /// | 2 | Xmm, Xmm |
5512    /// +---+----------+
5513    /// ```
5514    #[inline]
5515    pub fn sse_andpd<A, B>(&mut self, op0: A, op1: B)
5516    where
5517        Assembler<'a>: SseAndpdEmitter<A, B>,
5518    {
5519        <Self as SseAndpdEmitter<A, B>>::sse_andpd(self, op0, op1);
5520    }
5521    /// `SSE_CMPPD`.
5522    ///
5523    /// Supported operand variants:
5524    ///
5525    /// ```text
5526    /// +---+---------------+
5527    /// | # | Operands      |
5528    /// +---+---------------+
5529    /// | 1 | Xmm, Mem, Imm |
5530    /// | 2 | Xmm, Xmm, Imm |
5531    /// +---+---------------+
5532    /// ```
5533    #[inline]
5534    pub fn sse_cmppd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
5535    where
5536        Assembler<'a>: SseCmppdEmitter<A, B, C>,
5537    {
5538        <Self as SseCmppdEmitter<A, B, C>>::sse_cmppd(self, op0, op1, op2);
5539    }
5540    /// `SSE_CMPSD`.
5541    ///
5542    /// Supported operand variants:
5543    ///
5544    /// ```text
5545    /// +---+---------------+
5546    /// | # | Operands      |
5547    /// +---+---------------+
5548    /// | 1 | Xmm, Mem, Imm |
5549    /// | 2 | Xmm, Xmm, Imm |
5550    /// +---+---------------+
5551    /// ```
5552    #[inline]
5553    pub fn sse_cmpsd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
5554    where
5555        Assembler<'a>: SseCmpsdEmitter<A, B, C>,
5556    {
5557        <Self as SseCmpsdEmitter<A, B, C>>::sse_cmpsd(self, op0, op1, op2);
5558    }
5559    /// `SSE_COMISD`.
5560    ///
5561    /// Supported operand variants:
5562    ///
5563    /// ```text
5564    /// +---+----------+
5565    /// | # | Operands |
5566    /// +---+----------+
5567    /// | 1 | Xmm, Mem |
5568    /// | 2 | Xmm, Xmm |
5569    /// +---+----------+
5570    /// ```
5571    #[inline]
5572    pub fn sse_comisd<A, B>(&mut self, op0: A, op1: B)
5573    where
5574        Assembler<'a>: SseComisdEmitter<A, B>,
5575    {
5576        <Self as SseComisdEmitter<A, B>>::sse_comisd(self, op0, op1);
5577    }
5578    /// `SSE_CVTDQ2PD`.
5579    ///
5580    /// Supported operand variants:
5581    ///
5582    /// ```text
5583    /// +---+----------+
5584    /// | # | Operands |
5585    /// +---+----------+
5586    /// | 1 | Xmm, Mem |
5587    /// | 2 | Xmm, Xmm |
5588    /// +---+----------+
5589    /// ```
5590    #[inline]
5591    pub fn sse_cvtdq2pd<A, B>(&mut self, op0: A, op1: B)
5592    where
5593        Assembler<'a>: SseCvtdq2pdEmitter<A, B>,
5594    {
5595        <Self as SseCvtdq2pdEmitter<A, B>>::sse_cvtdq2pd(self, op0, op1);
5596    }
5597    /// `SSE_CVTDQ2PS`.
5598    ///
5599    /// Supported operand variants:
5600    ///
5601    /// ```text
5602    /// +---+----------+
5603    /// | # | Operands |
5604    /// +---+----------+
5605    /// | 1 | Xmm, Mem |
5606    /// | 2 | Xmm, Xmm |
5607    /// +---+----------+
5608    /// ```
5609    #[inline]
5610    pub fn sse_cvtdq2ps<A, B>(&mut self, op0: A, op1: B)
5611    where
5612        Assembler<'a>: SseCvtdq2psEmitter<A, B>,
5613    {
5614        <Self as SseCvtdq2psEmitter<A, B>>::sse_cvtdq2ps(self, op0, op1);
5615    }
5616    /// `SSE_CVTPD2DQ`.
5617    ///
5618    /// Supported operand variants:
5619    ///
5620    /// ```text
5621    /// +---+----------+
5622    /// | # | Operands |
5623    /// +---+----------+
5624    /// | 1 | Xmm, Mem |
5625    /// | 2 | Xmm, Xmm |
5626    /// +---+----------+
5627    /// ```
5628    #[inline]
5629    pub fn sse_cvtpd2dq<A, B>(&mut self, op0: A, op1: B)
5630    where
5631        Assembler<'a>: SseCvtpd2dqEmitter<A, B>,
5632    {
5633        <Self as SseCvtpd2dqEmitter<A, B>>::sse_cvtpd2dq(self, op0, op1);
5634    }
5635    /// `SSE_CVTPD2PS`.
5636    ///
5637    /// Supported operand variants:
5638    ///
5639    /// ```text
5640    /// +---+----------+
5641    /// | # | Operands |
5642    /// +---+----------+
5643    /// | 1 | Xmm, Mem |
5644    /// | 2 | Xmm, Xmm |
5645    /// +---+----------+
5646    /// ```
5647    #[inline]
5648    pub fn sse_cvtpd2ps<A, B>(&mut self, op0: A, op1: B)
5649    where
5650        Assembler<'a>: SseCvtpd2psEmitter<A, B>,
5651    {
5652        <Self as SseCvtpd2psEmitter<A, B>>::sse_cvtpd2ps(self, op0, op1);
5653    }
5654    /// `SSE_CVTPS2DQ`.
5655    ///
5656    /// Supported operand variants:
5657    ///
5658    /// ```text
5659    /// +---+----------+
5660    /// | # | Operands |
5661    /// +---+----------+
5662    /// | 1 | Xmm, Mem |
5663    /// | 2 | Xmm, Xmm |
5664    /// +---+----------+
5665    /// ```
5666    #[inline]
5667    pub fn sse_cvtps2dq<A, B>(&mut self, op0: A, op1: B)
5668    where
5669        Assembler<'a>: SseCvtps2dqEmitter<A, B>,
5670    {
5671        <Self as SseCvtps2dqEmitter<A, B>>::sse_cvtps2dq(self, op0, op1);
5672    }
5673    /// `SSE_CVTPS2PD`.
5674    ///
5675    /// Supported operand variants:
5676    ///
5677    /// ```text
5678    /// +---+----------+
5679    /// | # | Operands |
5680    /// +---+----------+
5681    /// | 1 | Xmm, Mem |
5682    /// | 2 | Xmm, Xmm |
5683    /// +---+----------+
5684    /// ```
5685    #[inline]
5686    pub fn sse_cvtps2pd<A, B>(&mut self, op0: A, op1: B)
5687    where
5688        Assembler<'a>: SseCvtps2pdEmitter<A, B>,
5689    {
5690        <Self as SseCvtps2pdEmitter<A, B>>::sse_cvtps2pd(self, op0, op1);
5691    }
5692    /// `SSE_CVTSD2SI`.
5693    ///
5694    /// Supported operand variants:
5695    ///
5696    /// ```text
5697    /// +---+----------+
5698    /// | # | Operands |
5699    /// +---+----------+
5700    /// | 1 | Gpd, Mem |
5701    /// | 2 | Gpd, Xmm |
5702    /// | 3 | Gpq, Mem |
5703    /// | 4 | Gpq, Xmm |
5704    /// +---+----------+
5705    /// ```
5706    #[inline]
5707    pub fn sse_cvtsd2si<A, B>(&mut self, op0: A, op1: B)
5708    where
5709        Assembler<'a>: SseCvtsd2siEmitter<A, B>,
5710    {
5711        <Self as SseCvtsd2siEmitter<A, B>>::sse_cvtsd2si(self, op0, op1);
5712    }
5713    /// `SSE_CVTSD2SS`.
5714    ///
5715    /// Supported operand variants:
5716    ///
5717    /// ```text
5718    /// +---+----------+
5719    /// | # | Operands |
5720    /// +---+----------+
5721    /// | 1 | Xmm, Mem |
5722    /// | 2 | Xmm, Xmm |
5723    /// +---+----------+
5724    /// ```
5725    #[inline]
5726    pub fn sse_cvtsd2ss<A, B>(&mut self, op0: A, op1: B)
5727    where
5728        Assembler<'a>: SseCvtsd2ssEmitter<A, B>,
5729    {
5730        <Self as SseCvtsd2ssEmitter<A, B>>::sse_cvtsd2ss(self, op0, op1);
5731    }
5732    /// `SSE_CVTSI2SD`.
5733    ///
5734    /// Supported operand variants:
5735    ///
5736    /// ```text
5737    /// +---+----------+
5738    /// | # | Operands |
5739    /// +---+----------+
5740    /// | 1 | Xmm, Gpd |
5741    /// | 2 | Xmm, Gpq |
5742    /// | 3 | Xmm, Mem |
5743    /// +---+----------+
5744    /// ```
5745    #[inline]
5746    pub fn sse_cvtsi2sd<A, B>(&mut self, op0: A, op1: B)
5747    where
5748        Assembler<'a>: SseCvtsi2sdEmitter<A, B>,
5749    {
5750        <Self as SseCvtsi2sdEmitter<A, B>>::sse_cvtsi2sd(self, op0, op1);
5751    }
5752    /// `SSE_CVTSS2SD`.
5753    ///
5754    /// Supported operand variants:
5755    ///
5756    /// ```text
5757    /// +---+----------+
5758    /// | # | Operands |
5759    /// +---+----------+
5760    /// | 1 | Xmm, Mem |
5761    /// | 2 | Xmm, Xmm |
5762    /// +---+----------+
5763    /// ```
5764    #[inline]
5765    pub fn sse_cvtss2sd<A, B>(&mut self, op0: A, op1: B)
5766    where
5767        Assembler<'a>: SseCvtss2sdEmitter<A, B>,
5768    {
5769        <Self as SseCvtss2sdEmitter<A, B>>::sse_cvtss2sd(self, op0, op1);
5770    }
5771    /// `SSE_CVTTPD2DQ`.
5772    ///
5773    /// Supported operand variants:
5774    ///
5775    /// ```text
5776    /// +---+----------+
5777    /// | # | Operands |
5778    /// +---+----------+
5779    /// | 1 | Xmm, Mem |
5780    /// | 2 | Xmm, Xmm |
5781    /// +---+----------+
5782    /// ```
5783    #[inline]
5784    pub fn sse_cvttpd2dq<A, B>(&mut self, op0: A, op1: B)
5785    where
5786        Assembler<'a>: SseCvttpd2dqEmitter<A, B>,
5787    {
5788        <Self as SseCvttpd2dqEmitter<A, B>>::sse_cvttpd2dq(self, op0, op1);
5789    }
5790    /// `SSE_CVTTPS2DQ`.
5791    ///
5792    /// Supported operand variants:
5793    ///
5794    /// ```text
5795    /// +---+----------+
5796    /// | # | Operands |
5797    /// +---+----------+
5798    /// | 1 | Xmm, Mem |
5799    /// | 2 | Xmm, Xmm |
5800    /// +---+----------+
5801    /// ```
5802    #[inline]
5803    pub fn sse_cvttps2dq<A, B>(&mut self, op0: A, op1: B)
5804    where
5805        Assembler<'a>: SseCvttps2dqEmitter<A, B>,
5806    {
5807        <Self as SseCvttps2dqEmitter<A, B>>::sse_cvttps2dq(self, op0, op1);
5808    }
5809    /// `SSE_CVTTSD2SI`.
5810    ///
5811    /// Supported operand variants:
5812    ///
5813    /// ```text
5814    /// +---+----------+
5815    /// | # | Operands |
5816    /// +---+----------+
5817    /// | 1 | Gpd, Mem |
5818    /// | 2 | Gpd, Xmm |
5819    /// | 3 | Gpq, Mem |
5820    /// | 4 | Gpq, Xmm |
5821    /// +---+----------+
5822    /// ```
5823    #[inline]
5824    pub fn sse_cvttsd2si<A, B>(&mut self, op0: A, op1: B)
5825    where
5826        Assembler<'a>: SseCvttsd2siEmitter<A, B>,
5827    {
5828        <Self as SseCvttsd2siEmitter<A, B>>::sse_cvttsd2si(self, op0, op1);
5829    }
5830    /// `SSE_DIVPD`.
5831    ///
5832    /// Supported operand variants:
5833    ///
5834    /// ```text
5835    /// +---+----------+
5836    /// | # | Operands |
5837    /// +---+----------+
5838    /// | 1 | Xmm, Mem |
5839    /// | 2 | Xmm, Xmm |
5840    /// +---+----------+
5841    /// ```
5842    #[inline]
5843    pub fn sse_divpd<A, B>(&mut self, op0: A, op1: B)
5844    where
5845        Assembler<'a>: SseDivpdEmitter<A, B>,
5846    {
5847        <Self as SseDivpdEmitter<A, B>>::sse_divpd(self, op0, op1);
5848    }
5849    /// `SSE_DIVSD`.
5850    ///
5851    /// Supported operand variants:
5852    ///
5853    /// ```text
5854    /// +---+----------+
5855    /// | # | Operands |
5856    /// +---+----------+
5857    /// | 1 | Xmm, Mem |
5858    /// | 2 | Xmm, Xmm |
5859    /// +---+----------+
5860    /// ```
5861    #[inline]
5862    pub fn sse_divsd<A, B>(&mut self, op0: A, op1: B)
5863    where
5864        Assembler<'a>: SseDivsdEmitter<A, B>,
5865    {
5866        <Self as SseDivsdEmitter<A, B>>::sse_divsd(self, op0, op1);
5867    }
5868    /// `SSE_MASKMOVDQU`.
5869    ///
5870    /// Supported operand variants:
5871    ///
5872    /// ```text
5873    /// +---+----------+
5874    /// | # | Operands |
5875    /// +---+----------+
5876    /// | 1 | Xmm, Xmm |
5877    /// +---+----------+
5878    /// ```
5879    #[inline]
5880    pub fn sse_maskmovdqu<A, B>(&mut self, op0: A, op1: B)
5881    where
5882        Assembler<'a>: SseMaskmovdquEmitter<A, B>,
5883    {
5884        <Self as SseMaskmovdquEmitter<A, B>>::sse_maskmovdqu(self, op0, op1);
5885    }
5886    /// `SSE_MAXPD`.
5887    ///
5888    /// Supported operand variants:
5889    ///
5890    /// ```text
5891    /// +---+----------+
5892    /// | # | Operands |
5893    /// +---+----------+
5894    /// | 1 | Xmm, Mem |
5895    /// | 2 | Xmm, Xmm |
5896    /// +---+----------+
5897    /// ```
5898    #[inline]
5899    pub fn sse_maxpd<A, B>(&mut self, op0: A, op1: B)
5900    where
5901        Assembler<'a>: SseMaxpdEmitter<A, B>,
5902    {
5903        <Self as SseMaxpdEmitter<A, B>>::sse_maxpd(self, op0, op1);
5904    }
5905    /// `SSE_MAXSD`.
5906    ///
5907    /// Supported operand variants:
5908    ///
5909    /// ```text
5910    /// +---+----------+
5911    /// | # | Operands |
5912    /// +---+----------+
5913    /// | 1 | Xmm, Mem |
5914    /// | 2 | Xmm, Xmm |
5915    /// +---+----------+
5916    /// ```
5917    #[inline]
5918    pub fn sse_maxsd<A, B>(&mut self, op0: A, op1: B)
5919    where
5920        Assembler<'a>: SseMaxsdEmitter<A, B>,
5921    {
5922        <Self as SseMaxsdEmitter<A, B>>::sse_maxsd(self, op0, op1);
5923    }
5924    /// `SSE_MINPD`.
5925    ///
5926    /// Supported operand variants:
5927    ///
5928    /// ```text
5929    /// +---+----------+
5930    /// | # | Operands |
5931    /// +---+----------+
5932    /// | 1 | Xmm, Mem |
5933    /// | 2 | Xmm, Xmm |
5934    /// +---+----------+
5935    /// ```
5936    #[inline]
5937    pub fn sse_minpd<A, B>(&mut self, op0: A, op1: B)
5938    where
5939        Assembler<'a>: SseMinpdEmitter<A, B>,
5940    {
5941        <Self as SseMinpdEmitter<A, B>>::sse_minpd(self, op0, op1);
5942    }
5943    /// `SSE_MINSD`.
5944    ///
5945    /// Supported operand variants:
5946    ///
5947    /// ```text
5948    /// +---+----------+
5949    /// | # | Operands |
5950    /// +---+----------+
5951    /// | 1 | Xmm, Mem |
5952    /// | 2 | Xmm, Xmm |
5953    /// +---+----------+
5954    /// ```
5955    #[inline]
5956    pub fn sse_minsd<A, B>(&mut self, op0: A, op1: B)
5957    where
5958        Assembler<'a>: SseMinsdEmitter<A, B>,
5959    {
5960        <Self as SseMinsdEmitter<A, B>>::sse_minsd(self, op0, op1);
5961    }
5962    /// `SSE_MOVAPD`.
5963    ///
5964    /// Supported operand variants:
5965    ///
5966    /// ```text
5967    /// +---+----------+
5968    /// | # | Operands |
5969    /// +---+----------+
5970    /// | 1 | Mem, Xmm |
5971    /// | 2 | Xmm, Mem |
5972    /// | 3 | Xmm, Xmm |
5973    /// +---+----------+
5974    /// ```
5975    #[inline]
5976    pub fn sse_movapd<A, B>(&mut self, op0: A, op1: B)
5977    where
5978        Assembler<'a>: SseMovapdEmitter<A, B>,
5979    {
5980        <Self as SseMovapdEmitter<A, B>>::sse_movapd(self, op0, op1);
5981    }
5982    /// `SSE_MOVDQA`.
5983    ///
5984    /// Supported operand variants:
5985    ///
5986    /// ```text
5987    /// +---+----------+
5988    /// | # | Operands |
5989    /// +---+----------+
5990    /// | 1 | Mem, Xmm |
5991    /// | 2 | Xmm, Mem |
5992    /// | 3 | Xmm, Xmm |
5993    /// +---+----------+
5994    /// ```
5995    #[inline]
5996    pub fn sse_movdqa<A, B>(&mut self, op0: A, op1: B)
5997    where
5998        Assembler<'a>: SseMovdqaEmitter<A, B>,
5999    {
6000        <Self as SseMovdqaEmitter<A, B>>::sse_movdqa(self, op0, op1);
6001    }
6002    /// `SSE_MOVDQU`.
6003    ///
6004    /// Supported operand variants:
6005    ///
6006    /// ```text
6007    /// +---+----------+
6008    /// | # | Operands |
6009    /// +---+----------+
6010    /// | 1 | Mem, Xmm |
6011    /// | 2 | Xmm, Mem |
6012    /// | 3 | Xmm, Xmm |
6013    /// +---+----------+
6014    /// ```
6015    #[inline]
6016    pub fn sse_movdqu<A, B>(&mut self, op0: A, op1: B)
6017    where
6018        Assembler<'a>: SseMovdquEmitter<A, B>,
6019    {
6020        <Self as SseMovdquEmitter<A, B>>::sse_movdqu(self, op0, op1);
6021    }
6022    /// `SSE_MOVD_G2X`.
6023    ///
6024    /// Supported operand variants:
6025    ///
6026    /// ```text
6027    /// +---+----------+
6028    /// | # | Operands |
6029    /// +---+----------+
6030    /// | 1 | Xmm, Gpd |
6031    /// | 2 | Xmm, Mem |
6032    /// +---+----------+
6033    /// ```
6034    #[inline]
6035    pub fn sse_movd_g2x<A, B>(&mut self, op0: A, op1: B)
6036    where
6037        Assembler<'a>: SseMovdG2xEmitter<A, B>,
6038    {
6039        <Self as SseMovdG2xEmitter<A, B>>::sse_movd_g2x(self, op0, op1);
6040    }
6041    /// `SSE_MOVD_X2G`.
6042    ///
6043    /// Supported operand variants:
6044    ///
6045    /// ```text
6046    /// +---+----------+
6047    /// | # | Operands |
6048    /// +---+----------+
6049    /// | 1 | Gpd, Xmm |
6050    /// | 2 | Mem, Xmm |
6051    /// +---+----------+
6052    /// ```
6053    #[inline]
6054    pub fn sse_movd_x2g<A, B>(&mut self, op0: A, op1: B)
6055    where
6056        Assembler<'a>: SseMovdX2gEmitter<A, B>,
6057    {
6058        <Self as SseMovdX2gEmitter<A, B>>::sse_movd_x2g(self, op0, op1);
6059    }
6060    /// `SSE_MOVHPD`.
6061    ///
6062    /// Supported operand variants:
6063    ///
6064    /// ```text
6065    /// +---+----------+
6066    /// | # | Operands |
6067    /// +---+----------+
6068    /// | 1 | Mem, Xmm |
6069    /// | 2 | Xmm, Mem |
6070    /// +---+----------+
6071    /// ```
6072    #[inline]
6073    pub fn sse_movhpd<A, B>(&mut self, op0: A, op1: B)
6074    where
6075        Assembler<'a>: SseMovhpdEmitter<A, B>,
6076    {
6077        <Self as SseMovhpdEmitter<A, B>>::sse_movhpd(self, op0, op1);
6078    }
6079    /// `SSE_MOVLPD`.
6080    ///
6081    /// Supported operand variants:
6082    ///
6083    /// ```text
6084    /// +---+----------+
6085    /// | # | Operands |
6086    /// +---+----------+
6087    /// | 1 | Mem, Xmm |
6088    /// | 2 | Xmm, Mem |
6089    /// +---+----------+
6090    /// ```
6091    #[inline]
6092    pub fn sse_movlpd<A, B>(&mut self, op0: A, op1: B)
6093    where
6094        Assembler<'a>: SseMovlpdEmitter<A, B>,
6095    {
6096        <Self as SseMovlpdEmitter<A, B>>::sse_movlpd(self, op0, op1);
6097    }
6098    /// `SSE_MOVMSKPD`.
6099    ///
6100    /// Supported operand variants:
6101    ///
6102    /// ```text
6103    /// +---+----------+
6104    /// | # | Operands |
6105    /// +---+----------+
6106    /// | 1 | Gpq, Xmm |
6107    /// +---+----------+
6108    /// ```
6109    #[inline]
6110    pub fn sse_movmskpd<A, B>(&mut self, op0: A, op1: B)
6111    where
6112        Assembler<'a>: SseMovmskpdEmitter<A, B>,
6113    {
6114        <Self as SseMovmskpdEmitter<A, B>>::sse_movmskpd(self, op0, op1);
6115    }
6116    /// `SSE_MOVNTDQ`.
6117    ///
6118    /// Supported operand variants:
6119    ///
6120    /// ```text
6121    /// +---+----------+
6122    /// | # | Operands |
6123    /// +---+----------+
6124    /// | 1 | Mem, Xmm |
6125    /// +---+----------+
6126    /// ```
6127    #[inline]
6128    pub fn sse_movntdq<A, B>(&mut self, op0: A, op1: B)
6129    where
6130        Assembler<'a>: SseMovntdqEmitter<A, B>,
6131    {
6132        <Self as SseMovntdqEmitter<A, B>>::sse_movntdq(self, op0, op1);
6133    }
6134    /// `SSE_MOVNTPD`.
6135    ///
6136    /// Supported operand variants:
6137    ///
6138    /// ```text
6139    /// +---+----------+
6140    /// | # | Operands |
6141    /// +---+----------+
6142    /// | 1 | Mem, Xmm |
6143    /// +---+----------+
6144    /// ```
6145    #[inline]
6146    pub fn sse_movntpd<A, B>(&mut self, op0: A, op1: B)
6147    where
6148        Assembler<'a>: SseMovntpdEmitter<A, B>,
6149    {
6150        <Self as SseMovntpdEmitter<A, B>>::sse_movntpd(self, op0, op1);
6151    }
6152    /// `SSE_MOVNTSD`.
6153    ///
6154    /// Supported operand variants:
6155    ///
6156    /// ```text
6157    /// +---+----------+
6158    /// | # | Operands |
6159    /// +---+----------+
6160    /// | 1 | Mem, Xmm |
6161    /// +---+----------+
6162    /// ```
6163    #[inline]
6164    pub fn sse_movntsd<A, B>(&mut self, op0: A, op1: B)
6165    where
6166        Assembler<'a>: SseMovntsdEmitter<A, B>,
6167    {
6168        <Self as SseMovntsdEmitter<A, B>>::sse_movntsd(self, op0, op1);
6169    }
6170    /// `SSE_MOVQ`.
6171    ///
6172    /// Supported operand variants:
6173    ///
6174    /// ```text
6175    /// +---+----------+
6176    /// | # | Operands |
6177    /// +---+----------+
6178    /// | 1 | Mem, Xmm |
6179    /// | 2 | Xmm, Mem |
6180    /// | 3 | Xmm, Xmm |
6181    /// +---+----------+
6182    /// ```
6183    #[inline]
6184    pub fn sse_movq<A, B>(&mut self, op0: A, op1: B)
6185    where
6186        Assembler<'a>: SseMovqEmitter<A, B>,
6187    {
6188        <Self as SseMovqEmitter<A, B>>::sse_movq(self, op0, op1);
6189    }
6190    /// `SSE_MOVQ_G2X`.
6191    ///
6192    /// Supported operand variants:
6193    ///
6194    /// ```text
6195    /// +---+----------+
6196    /// | # | Operands |
6197    /// +---+----------+
6198    /// | 1 | Xmm, Gpd |
6199    /// | 2 | Xmm, Mem |
6200    /// +---+----------+
6201    /// ```
6202    #[inline]
6203    pub fn sse_movq_g2x<A, B>(&mut self, op0: A, op1: B)
6204    where
6205        Assembler<'a>: SseMovqG2xEmitter<A, B>,
6206    {
6207        <Self as SseMovqG2xEmitter<A, B>>::sse_movq_g2x(self, op0, op1);
6208    }
6209    /// `SSE_MOVQ_X2G`.
6210    ///
6211    /// Supported operand variants:
6212    ///
6213    /// ```text
6214    /// +---+----------+
6215    /// | # | Operands |
6216    /// +---+----------+
6217    /// | 1 | Gpd, Xmm |
6218    /// | 2 | Mem, Xmm |
6219    /// +---+----------+
6220    /// ```
6221    #[inline]
6222    pub fn sse_movq_x2g<A, B>(&mut self, op0: A, op1: B)
6223    where
6224        Assembler<'a>: SseMovqX2gEmitter<A, B>,
6225    {
6226        <Self as SseMovqX2gEmitter<A, B>>::sse_movq_x2g(self, op0, op1);
6227    }
6228    /// `SSE_MOVSD`.
6229    ///
6230    /// Supported operand variants:
6231    ///
6232    /// ```text
6233    /// +---+----------+
6234    /// | # | Operands |
6235    /// +---+----------+
6236    /// | 1 | Mem, Xmm |
6237    /// | 2 | Xmm, Mem |
6238    /// | 3 | Xmm, Xmm |
6239    /// +---+----------+
6240    /// ```
6241    #[inline]
6242    pub fn sse_movsd<A, B>(&mut self, op0: A, op1: B)
6243    where
6244        Assembler<'a>: SseMovsdEmitter<A, B>,
6245    {
6246        <Self as SseMovsdEmitter<A, B>>::sse_movsd(self, op0, op1);
6247    }
6248    /// `SSE_MOVUPD`.
6249    ///
6250    /// Supported operand variants:
6251    ///
6252    /// ```text
6253    /// +---+----------+
6254    /// | # | Operands |
6255    /// +---+----------+
6256    /// | 1 | Mem, Xmm |
6257    /// | 2 | Xmm, Mem |
6258    /// | 3 | Xmm, Xmm |
6259    /// +---+----------+
6260    /// ```
6261    #[inline]
6262    pub fn sse_movupd<A, B>(&mut self, op0: A, op1: B)
6263    where
6264        Assembler<'a>: SseMovupdEmitter<A, B>,
6265    {
6266        <Self as SseMovupdEmitter<A, B>>::sse_movupd(self, op0, op1);
6267    }
6268    /// `SSE_MULPD`.
6269    ///
6270    /// Supported operand variants:
6271    ///
6272    /// ```text
6273    /// +---+----------+
6274    /// | # | Operands |
6275    /// +---+----------+
6276    /// | 1 | Xmm, Mem |
6277    /// | 2 | Xmm, Xmm |
6278    /// +---+----------+
6279    /// ```
6280    #[inline]
6281    pub fn sse_mulpd<A, B>(&mut self, op0: A, op1: B)
6282    where
6283        Assembler<'a>: SseMulpdEmitter<A, B>,
6284    {
6285        <Self as SseMulpdEmitter<A, B>>::sse_mulpd(self, op0, op1);
6286    }
6287    /// `SSE_MULSD`.
6288    ///
6289    /// Supported operand variants:
6290    ///
6291    /// ```text
6292    /// +---+----------+
6293    /// | # | Operands |
6294    /// +---+----------+
6295    /// | 1 | Xmm, Mem |
6296    /// | 2 | Xmm, Xmm |
6297    /// +---+----------+
6298    /// ```
6299    #[inline]
6300    pub fn sse_mulsd<A, B>(&mut self, op0: A, op1: B)
6301    where
6302        Assembler<'a>: SseMulsdEmitter<A, B>,
6303    {
6304        <Self as SseMulsdEmitter<A, B>>::sse_mulsd(self, op0, op1);
6305    }
6306    /// `SSE_ORPD`.
6307    ///
6308    /// Supported operand variants:
6309    ///
6310    /// ```text
6311    /// +---+----------+
6312    /// | # | Operands |
6313    /// +---+----------+
6314    /// | 1 | Xmm, Mem |
6315    /// | 2 | Xmm, Xmm |
6316    /// +---+----------+
6317    /// ```
6318    #[inline]
6319    pub fn sse_orpd<A, B>(&mut self, op0: A, op1: B)
6320    where
6321        Assembler<'a>: SseOrpdEmitter<A, B>,
6322    {
6323        <Self as SseOrpdEmitter<A, B>>::sse_orpd(self, op0, op1);
6324    }
6325    /// `SSE_PACKSSDW`.
6326    ///
6327    /// Supported operand variants:
6328    ///
6329    /// ```text
6330    /// +---+----------+
6331    /// | # | Operands |
6332    /// +---+----------+
6333    /// | 1 | Xmm, Mem |
6334    /// | 2 | Xmm, Xmm |
6335    /// +---+----------+
6336    /// ```
6337    #[inline]
6338    pub fn sse_packssdw<A, B>(&mut self, op0: A, op1: B)
6339    where
6340        Assembler<'a>: SsePackssdwEmitter<A, B>,
6341    {
6342        <Self as SsePackssdwEmitter<A, B>>::sse_packssdw(self, op0, op1);
6343    }
6344    /// `SSE_PACKSSWB`.
6345    ///
6346    /// Supported operand variants:
6347    ///
6348    /// ```text
6349    /// +---+----------+
6350    /// | # | Operands |
6351    /// +---+----------+
6352    /// | 1 | Xmm, Mem |
6353    /// | 2 | Xmm, Xmm |
6354    /// +---+----------+
6355    /// ```
6356    #[inline]
6357    pub fn sse_packsswb<A, B>(&mut self, op0: A, op1: B)
6358    where
6359        Assembler<'a>: SsePacksswbEmitter<A, B>,
6360    {
6361        <Self as SsePacksswbEmitter<A, B>>::sse_packsswb(self, op0, op1);
6362    }
6363    /// `SSE_PACKUSWB`.
6364    ///
6365    /// Supported operand variants:
6366    ///
6367    /// ```text
6368    /// +---+----------+
6369    /// | # | Operands |
6370    /// +---+----------+
6371    /// | 1 | Xmm, Mem |
6372    /// | 2 | Xmm, Xmm |
6373    /// +---+----------+
6374    /// ```
6375    #[inline]
6376    pub fn sse_packuswb<A, B>(&mut self, op0: A, op1: B)
6377    where
6378        Assembler<'a>: SsePackuswbEmitter<A, B>,
6379    {
6380        <Self as SsePackuswbEmitter<A, B>>::sse_packuswb(self, op0, op1);
6381    }
6382    /// `SSE_PADDB`.
6383    ///
6384    /// Supported operand variants:
6385    ///
6386    /// ```text
6387    /// +---+----------+
6388    /// | # | Operands |
6389    /// +---+----------+
6390    /// | 1 | Xmm, Mem |
6391    /// | 2 | Xmm, Xmm |
6392    /// +---+----------+
6393    /// ```
6394    #[inline]
6395    pub fn sse_paddb<A, B>(&mut self, op0: A, op1: B)
6396    where
6397        Assembler<'a>: SsePaddbEmitter<A, B>,
6398    {
6399        <Self as SsePaddbEmitter<A, B>>::sse_paddb(self, op0, op1);
6400    }
6401    /// `SSE_PADDD`.
6402    ///
6403    /// Supported operand variants:
6404    ///
6405    /// ```text
6406    /// +---+----------+
6407    /// | # | Operands |
6408    /// +---+----------+
6409    /// | 1 | Xmm, Mem |
6410    /// | 2 | Xmm, Xmm |
6411    /// +---+----------+
6412    /// ```
6413    #[inline]
6414    pub fn sse_paddd<A, B>(&mut self, op0: A, op1: B)
6415    where
6416        Assembler<'a>: SsePadddEmitter<A, B>,
6417    {
6418        <Self as SsePadddEmitter<A, B>>::sse_paddd(self, op0, op1);
6419    }
6420    /// `SSE_PADDQ`.
6421    ///
6422    /// Supported operand variants:
6423    ///
6424    /// ```text
6425    /// +---+----------+
6426    /// | # | Operands |
6427    /// +---+----------+
6428    /// | 1 | Xmm, Mem |
6429    /// | 2 | Xmm, Xmm |
6430    /// +---+----------+
6431    /// ```
6432    #[inline]
6433    pub fn sse_paddq<A, B>(&mut self, op0: A, op1: B)
6434    where
6435        Assembler<'a>: SsePaddqEmitter<A, B>,
6436    {
6437        <Self as SsePaddqEmitter<A, B>>::sse_paddq(self, op0, op1);
6438    }
6439    /// `SSE_PADDSB`.
6440    ///
6441    /// Supported operand variants:
6442    ///
6443    /// ```text
6444    /// +---+----------+
6445    /// | # | Operands |
6446    /// +---+----------+
6447    /// | 1 | Xmm, Mem |
6448    /// | 2 | Xmm, Xmm |
6449    /// +---+----------+
6450    /// ```
6451    #[inline]
6452    pub fn sse_paddsb<A, B>(&mut self, op0: A, op1: B)
6453    where
6454        Assembler<'a>: SsePaddsbEmitter<A, B>,
6455    {
6456        <Self as SsePaddsbEmitter<A, B>>::sse_paddsb(self, op0, op1);
6457    }
6458    /// `SSE_PADDSW`.
6459    ///
6460    /// Supported operand variants:
6461    ///
6462    /// ```text
6463    /// +---+----------+
6464    /// | # | Operands |
6465    /// +---+----------+
6466    /// | 1 | Xmm, Mem |
6467    /// | 2 | Xmm, Xmm |
6468    /// +---+----------+
6469    /// ```
6470    #[inline]
6471    pub fn sse_paddsw<A, B>(&mut self, op0: A, op1: B)
6472    where
6473        Assembler<'a>: SsePaddswEmitter<A, B>,
6474    {
6475        <Self as SsePaddswEmitter<A, B>>::sse_paddsw(self, op0, op1);
6476    }
6477    /// `SSE_PADDUSB`.
6478    ///
6479    /// Supported operand variants:
6480    ///
6481    /// ```text
6482    /// +---+----------+
6483    /// | # | Operands |
6484    /// +---+----------+
6485    /// | 1 | Xmm, Mem |
6486    /// | 2 | Xmm, Xmm |
6487    /// +---+----------+
6488    /// ```
6489    #[inline]
6490    pub fn sse_paddusb<A, B>(&mut self, op0: A, op1: B)
6491    where
6492        Assembler<'a>: SsePaddusbEmitter<A, B>,
6493    {
6494        <Self as SsePaddusbEmitter<A, B>>::sse_paddusb(self, op0, op1);
6495    }
6496    /// `SSE_PADDUSW`.
6497    ///
6498    /// Supported operand variants:
6499    ///
6500    /// ```text
6501    /// +---+----------+
6502    /// | # | Operands |
6503    /// +---+----------+
6504    /// | 1 | Xmm, Mem |
6505    /// | 2 | Xmm, Xmm |
6506    /// +---+----------+
6507    /// ```
6508    #[inline]
6509    pub fn sse_paddusw<A, B>(&mut self, op0: A, op1: B)
6510    where
6511        Assembler<'a>: SsePadduswEmitter<A, B>,
6512    {
6513        <Self as SsePadduswEmitter<A, B>>::sse_paddusw(self, op0, op1);
6514    }
6515    /// `SSE_PADDW`.
6516    ///
6517    /// Supported operand variants:
6518    ///
6519    /// ```text
6520    /// +---+----------+
6521    /// | # | Operands |
6522    /// +---+----------+
6523    /// | 1 | Xmm, Mem |
6524    /// | 2 | Xmm, Xmm |
6525    /// +---+----------+
6526    /// ```
6527    #[inline]
6528    pub fn sse_paddw<A, B>(&mut self, op0: A, op1: B)
6529    where
6530        Assembler<'a>: SsePaddwEmitter<A, B>,
6531    {
6532        <Self as SsePaddwEmitter<A, B>>::sse_paddw(self, op0, op1);
6533    }
6534    /// `SSE_PAND`.
6535    ///
6536    /// Supported operand variants:
6537    ///
6538    /// ```text
6539    /// +---+----------+
6540    /// | # | Operands |
6541    /// +---+----------+
6542    /// | 1 | Xmm, Mem |
6543    /// | 2 | Xmm, Xmm |
6544    /// +---+----------+
6545    /// ```
6546    #[inline]
6547    pub fn sse_pand<A, B>(&mut self, op0: A, op1: B)
6548    where
6549        Assembler<'a>: SsePandEmitter<A, B>,
6550    {
6551        <Self as SsePandEmitter<A, B>>::sse_pand(self, op0, op1);
6552    }
6553    /// `SSE_PANDN`.
6554    ///
6555    /// Supported operand variants:
6556    ///
6557    /// ```text
6558    /// +---+----------+
6559    /// | # | Operands |
6560    /// +---+----------+
6561    /// | 1 | Xmm, Mem |
6562    /// | 2 | Xmm, Xmm |
6563    /// +---+----------+
6564    /// ```
6565    #[inline]
6566    pub fn sse_pandn<A, B>(&mut self, op0: A, op1: B)
6567    where
6568        Assembler<'a>: SsePandnEmitter<A, B>,
6569    {
6570        <Self as SsePandnEmitter<A, B>>::sse_pandn(self, op0, op1);
6571    }
6572    /// `SSE_PAVGB`.
6573    ///
6574    /// Supported operand variants:
6575    ///
6576    /// ```text
6577    /// +---+----------+
6578    /// | # | Operands |
6579    /// +---+----------+
6580    /// | 1 | Xmm, Mem |
6581    /// | 2 | Xmm, Xmm |
6582    /// +---+----------+
6583    /// ```
6584    #[inline]
6585    pub fn sse_pavgb<A, B>(&mut self, op0: A, op1: B)
6586    where
6587        Assembler<'a>: SsePavgbEmitter<A, B>,
6588    {
6589        <Self as SsePavgbEmitter<A, B>>::sse_pavgb(self, op0, op1);
6590    }
6591    /// `SSE_PAVGW`.
6592    ///
6593    /// Supported operand variants:
6594    ///
6595    /// ```text
6596    /// +---+----------+
6597    /// | # | Operands |
6598    /// +---+----------+
6599    /// | 1 | Xmm, Mem |
6600    /// | 2 | Xmm, Xmm |
6601    /// +---+----------+
6602    /// ```
6603    #[inline]
6604    pub fn sse_pavgw<A, B>(&mut self, op0: A, op1: B)
6605    where
6606        Assembler<'a>: SsePavgwEmitter<A, B>,
6607    {
6608        <Self as SsePavgwEmitter<A, B>>::sse_pavgw(self, op0, op1);
6609    }
6610    /// `SSE_PCMPEQB`.
6611    ///
6612    /// Supported operand variants:
6613    ///
6614    /// ```text
6615    /// +---+----------+
6616    /// | # | Operands |
6617    /// +---+----------+
6618    /// | 1 | Xmm, Mem |
6619    /// | 2 | Xmm, Xmm |
6620    /// +---+----------+
6621    /// ```
6622    #[inline]
6623    pub fn sse_pcmpeqb<A, B>(&mut self, op0: A, op1: B)
6624    where
6625        Assembler<'a>: SsePcmpeqbEmitter<A, B>,
6626    {
6627        <Self as SsePcmpeqbEmitter<A, B>>::sse_pcmpeqb(self, op0, op1);
6628    }
6629    /// `SSE_PCMPEQD`.
6630    ///
6631    /// Supported operand variants:
6632    ///
6633    /// ```text
6634    /// +---+----------+
6635    /// | # | Operands |
6636    /// +---+----------+
6637    /// | 1 | Xmm, Mem |
6638    /// | 2 | Xmm, Xmm |
6639    /// +---+----------+
6640    /// ```
6641    #[inline]
6642    pub fn sse_pcmpeqd<A, B>(&mut self, op0: A, op1: B)
6643    where
6644        Assembler<'a>: SsePcmpeqdEmitter<A, B>,
6645    {
6646        <Self as SsePcmpeqdEmitter<A, B>>::sse_pcmpeqd(self, op0, op1);
6647    }
6648    /// `SSE_PCMPEQW`.
6649    ///
6650    /// Supported operand variants:
6651    ///
6652    /// ```text
6653    /// +---+----------+
6654    /// | # | Operands |
6655    /// +---+----------+
6656    /// | 1 | Xmm, Mem |
6657    /// | 2 | Xmm, Xmm |
6658    /// +---+----------+
6659    /// ```
6660    #[inline]
6661    pub fn sse_pcmpeqw<A, B>(&mut self, op0: A, op1: B)
6662    where
6663        Assembler<'a>: SsePcmpeqwEmitter<A, B>,
6664    {
6665        <Self as SsePcmpeqwEmitter<A, B>>::sse_pcmpeqw(self, op0, op1);
6666    }
6667    /// `SSE_PCMPGTB`.
6668    ///
6669    /// Supported operand variants:
6670    ///
6671    /// ```text
6672    /// +---+----------+
6673    /// | # | Operands |
6674    /// +---+----------+
6675    /// | 1 | Xmm, Mem |
6676    /// | 2 | Xmm, Xmm |
6677    /// +---+----------+
6678    /// ```
6679    #[inline]
6680    pub fn sse_pcmpgtb<A, B>(&mut self, op0: A, op1: B)
6681    where
6682        Assembler<'a>: SsePcmpgtbEmitter<A, B>,
6683    {
6684        <Self as SsePcmpgtbEmitter<A, B>>::sse_pcmpgtb(self, op0, op1);
6685    }
6686    /// `SSE_PCMPGTD`.
6687    ///
6688    /// Supported operand variants:
6689    ///
6690    /// ```text
6691    /// +---+----------+
6692    /// | # | Operands |
6693    /// +---+----------+
6694    /// | 1 | Xmm, Mem |
6695    /// | 2 | Xmm, Xmm |
6696    /// +---+----------+
6697    /// ```
6698    #[inline]
6699    pub fn sse_pcmpgtd<A, B>(&mut self, op0: A, op1: B)
6700    where
6701        Assembler<'a>: SsePcmpgtdEmitter<A, B>,
6702    {
6703        <Self as SsePcmpgtdEmitter<A, B>>::sse_pcmpgtd(self, op0, op1);
6704    }
6705    /// `SSE_PCMPGTW`.
6706    ///
6707    /// Supported operand variants:
6708    ///
6709    /// ```text
6710    /// +---+----------+
6711    /// | # | Operands |
6712    /// +---+----------+
6713    /// | 1 | Xmm, Mem |
6714    /// | 2 | Xmm, Xmm |
6715    /// +---+----------+
6716    /// ```
6717    #[inline]
6718    pub fn sse_pcmpgtw<A, B>(&mut self, op0: A, op1: B)
6719    where
6720        Assembler<'a>: SsePcmpgtwEmitter<A, B>,
6721    {
6722        <Self as SsePcmpgtwEmitter<A, B>>::sse_pcmpgtw(self, op0, op1);
6723    }
6724    /// `SSE_PEXTRW`.
6725    ///
6726    /// Supported operand variants:
6727    ///
6728    /// ```text
6729    /// +---+---------------+
6730    /// | # | Operands      |
6731    /// +---+---------------+
6732    /// | 1 | Gpd, Xmm, Imm |
6733    /// | 2 | Mem, Xmm, Imm |
6734    /// +---+---------------+
6735    /// ```
6736    #[inline]
6737    pub fn sse_pextrw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
6738    where
6739        Assembler<'a>: SsePextrwEmitter<A, B, C>,
6740    {
6741        <Self as SsePextrwEmitter<A, B, C>>::sse_pextrw(self, op0, op1, op2);
6742    }
6743    /// `SSE_PINSRW`.
6744    ///
6745    /// Supported operand variants:
6746    ///
6747    /// ```text
6748    /// +---+---------------+
6749    /// | # | Operands      |
6750    /// +---+---------------+
6751    /// | 1 | Xmm, Gpd, Imm |
6752    /// | 2 | Xmm, Mem, Imm |
6753    /// +---+---------------+
6754    /// ```
6755    #[inline]
6756    pub fn sse_pinsrw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
6757    where
6758        Assembler<'a>: SsePinsrwEmitter<A, B, C>,
6759    {
6760        <Self as SsePinsrwEmitter<A, B, C>>::sse_pinsrw(self, op0, op1, op2);
6761    }
6762    /// `SSE_PMADDWD`.
6763    ///
6764    /// Supported operand variants:
6765    ///
6766    /// ```text
6767    /// +---+----------+
6768    /// | # | Operands |
6769    /// +---+----------+
6770    /// | 1 | Xmm, Mem |
6771    /// | 2 | Xmm, Xmm |
6772    /// +---+----------+
6773    /// ```
6774    #[inline]
6775    pub fn sse_pmaddwd<A, B>(&mut self, op0: A, op1: B)
6776    where
6777        Assembler<'a>: SsePmaddwdEmitter<A, B>,
6778    {
6779        <Self as SsePmaddwdEmitter<A, B>>::sse_pmaddwd(self, op0, op1);
6780    }
6781    /// `SSE_PMAXSW`.
6782    ///
6783    /// Supported operand variants:
6784    ///
6785    /// ```text
6786    /// +---+----------+
6787    /// | # | Operands |
6788    /// +---+----------+
6789    /// | 1 | Xmm, Mem |
6790    /// | 2 | Xmm, Xmm |
6791    /// +---+----------+
6792    /// ```
6793    #[inline]
6794    pub fn sse_pmaxsw<A, B>(&mut self, op0: A, op1: B)
6795    where
6796        Assembler<'a>: SsePmaxswEmitter<A, B>,
6797    {
6798        <Self as SsePmaxswEmitter<A, B>>::sse_pmaxsw(self, op0, op1);
6799    }
6800    /// `SSE_PMAXUB`.
6801    ///
6802    /// Supported operand variants:
6803    ///
6804    /// ```text
6805    /// +---+----------+
6806    /// | # | Operands |
6807    /// +---+----------+
6808    /// | 1 | Xmm, Mem |
6809    /// | 2 | Xmm, Xmm |
6810    /// +---+----------+
6811    /// ```
6812    #[inline]
6813    pub fn sse_pmaxub<A, B>(&mut self, op0: A, op1: B)
6814    where
6815        Assembler<'a>: SsePmaxubEmitter<A, B>,
6816    {
6817        <Self as SsePmaxubEmitter<A, B>>::sse_pmaxub(self, op0, op1);
6818    }
6819    /// `SSE_PMINSW`.
6820    ///
6821    /// Supported operand variants:
6822    ///
6823    /// ```text
6824    /// +---+----------+
6825    /// | # | Operands |
6826    /// +---+----------+
6827    /// | 1 | Xmm, Mem |
6828    /// | 2 | Xmm, Xmm |
6829    /// +---+----------+
6830    /// ```
6831    #[inline]
6832    pub fn sse_pminsw<A, B>(&mut self, op0: A, op1: B)
6833    where
6834        Assembler<'a>: SsePminswEmitter<A, B>,
6835    {
6836        <Self as SsePminswEmitter<A, B>>::sse_pminsw(self, op0, op1);
6837    }
6838    /// `SSE_PMINUB`.
6839    ///
6840    /// Supported operand variants:
6841    ///
6842    /// ```text
6843    /// +---+----------+
6844    /// | # | Operands |
6845    /// +---+----------+
6846    /// | 1 | Xmm, Mem |
6847    /// | 2 | Xmm, Xmm |
6848    /// +---+----------+
6849    /// ```
6850    #[inline]
6851    pub fn sse_pminub<A, B>(&mut self, op0: A, op1: B)
6852    where
6853        Assembler<'a>: SsePminubEmitter<A, B>,
6854    {
6855        <Self as SsePminubEmitter<A, B>>::sse_pminub(self, op0, op1);
6856    }
6857    /// `SSE_PMOVMSKB`.
6858    ///
6859    /// Supported operand variants:
6860    ///
6861    /// ```text
6862    /// +---+----------+
6863    /// | # | Operands |
6864    /// +---+----------+
6865    /// | 1 | Gpq, Xmm |
6866    /// +---+----------+
6867    /// ```
6868    #[inline]
6869    pub fn sse_pmovmskb<A, B>(&mut self, op0: A, op1: B)
6870    where
6871        Assembler<'a>: SsePmovmskbEmitter<A, B>,
6872    {
6873        <Self as SsePmovmskbEmitter<A, B>>::sse_pmovmskb(self, op0, op1);
6874    }
6875    /// `SSE_PMULHUW`.
6876    ///
6877    /// Supported operand variants:
6878    ///
6879    /// ```text
6880    /// +---+----------+
6881    /// | # | Operands |
6882    /// +---+----------+
6883    /// | 1 | Xmm, Mem |
6884    /// | 2 | Xmm, Xmm |
6885    /// +---+----------+
6886    /// ```
6887    #[inline]
6888    pub fn sse_pmulhuw<A, B>(&mut self, op0: A, op1: B)
6889    where
6890        Assembler<'a>: SsePmulhuwEmitter<A, B>,
6891    {
6892        <Self as SsePmulhuwEmitter<A, B>>::sse_pmulhuw(self, op0, op1);
6893    }
6894    /// `SSE_PMULHW`.
6895    ///
6896    /// Supported operand variants:
6897    ///
6898    /// ```text
6899    /// +---+----------+
6900    /// | # | Operands |
6901    /// +---+----------+
6902    /// | 1 | Xmm, Mem |
6903    /// | 2 | Xmm, Xmm |
6904    /// +---+----------+
6905    /// ```
6906    #[inline]
6907    pub fn sse_pmulhw<A, B>(&mut self, op0: A, op1: B)
6908    where
6909        Assembler<'a>: SsePmulhwEmitter<A, B>,
6910    {
6911        <Self as SsePmulhwEmitter<A, B>>::sse_pmulhw(self, op0, op1);
6912    }
6913    /// `SSE_PMULLW`.
6914    ///
6915    /// Supported operand variants:
6916    ///
6917    /// ```text
6918    /// +---+----------+
6919    /// | # | Operands |
6920    /// +---+----------+
6921    /// | 1 | Xmm, Mem |
6922    /// | 2 | Xmm, Xmm |
6923    /// +---+----------+
6924    /// ```
6925    #[inline]
6926    pub fn sse_pmullw<A, B>(&mut self, op0: A, op1: B)
6927    where
6928        Assembler<'a>: SsePmullwEmitter<A, B>,
6929    {
6930        <Self as SsePmullwEmitter<A, B>>::sse_pmullw(self, op0, op1);
6931    }
6932    /// `SSE_PMULUDQ`.
6933    ///
6934    /// Supported operand variants:
6935    ///
6936    /// ```text
6937    /// +---+----------+
6938    /// | # | Operands |
6939    /// +---+----------+
6940    /// | 1 | Xmm, Mem |
6941    /// | 2 | Xmm, Xmm |
6942    /// +---+----------+
6943    /// ```
6944    #[inline]
6945    pub fn sse_pmuludq<A, B>(&mut self, op0: A, op1: B)
6946    where
6947        Assembler<'a>: SsePmuludqEmitter<A, B>,
6948    {
6949        <Self as SsePmuludqEmitter<A, B>>::sse_pmuludq(self, op0, op1);
6950    }
6951    /// `SSE_POR`.
6952    ///
6953    /// Supported operand variants:
6954    ///
6955    /// ```text
6956    /// +---+----------+
6957    /// | # | Operands |
6958    /// +---+----------+
6959    /// | 1 | Xmm, Mem |
6960    /// | 2 | Xmm, Xmm |
6961    /// +---+----------+
6962    /// ```
6963    #[inline]
6964    pub fn sse_por<A, B>(&mut self, op0: A, op1: B)
6965    where
6966        Assembler<'a>: SsePorEmitter<A, B>,
6967    {
6968        <Self as SsePorEmitter<A, B>>::sse_por(self, op0, op1);
6969    }
6970    /// `SSE_PSADBW`.
6971    ///
6972    /// Supported operand variants:
6973    ///
6974    /// ```text
6975    /// +---+----------+
6976    /// | # | Operands |
6977    /// +---+----------+
6978    /// | 1 | Xmm, Mem |
6979    /// | 2 | Xmm, Xmm |
6980    /// +---+----------+
6981    /// ```
6982    #[inline]
6983    pub fn sse_psadbw<A, B>(&mut self, op0: A, op1: B)
6984    where
6985        Assembler<'a>: SsePsadbwEmitter<A, B>,
6986    {
6987        <Self as SsePsadbwEmitter<A, B>>::sse_psadbw(self, op0, op1);
6988    }
6989    /// `SSE_PSHUFD`.
6990    ///
6991    /// Supported operand variants:
6992    ///
6993    /// ```text
6994    /// +---+---------------+
6995    /// | # | Operands      |
6996    /// +---+---------------+
6997    /// | 1 | Xmm, Mem, Imm |
6998    /// | 2 | Xmm, Xmm, Imm |
6999    /// +---+---------------+
7000    /// ```
7001    #[inline]
7002    pub fn sse_pshufd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
7003    where
7004        Assembler<'a>: SsePshufdEmitter<A, B, C>,
7005    {
7006        <Self as SsePshufdEmitter<A, B, C>>::sse_pshufd(self, op0, op1, op2);
7007    }
7008    /// `SSE_PSHUFHW`.
7009    ///
7010    /// Supported operand variants:
7011    ///
7012    /// ```text
7013    /// +---+---------------+
7014    /// | # | Operands      |
7015    /// +---+---------------+
7016    /// | 1 | Xmm, Mem, Imm |
7017    /// | 2 | Xmm, Xmm, Imm |
7018    /// +---+---------------+
7019    /// ```
7020    #[inline]
7021    pub fn sse_pshufhw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
7022    where
7023        Assembler<'a>: SsePshufhwEmitter<A, B, C>,
7024    {
7025        <Self as SsePshufhwEmitter<A, B, C>>::sse_pshufhw(self, op0, op1, op2);
7026    }
7027    /// `SSE_PSHUFLW`.
7028    ///
7029    /// Supported operand variants:
7030    ///
7031    /// ```text
7032    /// +---+---------------+
7033    /// | # | Operands      |
7034    /// +---+---------------+
7035    /// | 1 | Xmm, Mem, Imm |
7036    /// | 2 | Xmm, Xmm, Imm |
7037    /// +---+---------------+
7038    /// ```
7039    #[inline]
7040    pub fn sse_pshuflw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
7041    where
7042        Assembler<'a>: SsePshuflwEmitter<A, B, C>,
7043    {
7044        <Self as SsePshuflwEmitter<A, B, C>>::sse_pshuflw(self, op0, op1, op2);
7045    }
7046    /// `SSE_PSLLD`.
7047    ///
7048    /// Supported operand variants:
7049    ///
7050    /// ```text
7051    /// +---+----------+
7052    /// | # | Operands |
7053    /// +---+----------+
7054    /// | 1 | Xmm, Imm |
7055    /// | 2 | Xmm, Mem |
7056    /// | 3 | Xmm, Xmm |
7057    /// +---+----------+
7058    /// ```
7059    #[inline]
7060    pub fn sse_pslld<A, B>(&mut self, op0: A, op1: B)
7061    where
7062        Assembler<'a>: SsePslldEmitter<A, B>,
7063    {
7064        <Self as SsePslldEmitter<A, B>>::sse_pslld(self, op0, op1);
7065    }
7066    /// `SSE_PSLLDQ`.
7067    ///
7068    /// Supported operand variants:
7069    ///
7070    /// ```text
7071    /// +---+----------+
7072    /// | # | Operands |
7073    /// +---+----------+
7074    /// | 1 | Xmm, Imm |
7075    /// +---+----------+
7076    /// ```
7077    #[inline]
7078    pub fn sse_pslldq<A, B>(&mut self, op0: A, op1: B)
7079    where
7080        Assembler<'a>: SsePslldqEmitter<A, B>,
7081    {
7082        <Self as SsePslldqEmitter<A, B>>::sse_pslldq(self, op0, op1);
7083    }
7084    /// `SSE_PSLLQ`.
7085    ///
7086    /// Supported operand variants:
7087    ///
7088    /// ```text
7089    /// +---+----------+
7090    /// | # | Operands |
7091    /// +---+----------+
7092    /// | 1 | Xmm, Imm |
7093    /// | 2 | Xmm, Mem |
7094    /// | 3 | Xmm, Xmm |
7095    /// +---+----------+
7096    /// ```
7097    #[inline]
7098    pub fn sse_psllq<A, B>(&mut self, op0: A, op1: B)
7099    where
7100        Assembler<'a>: SsePsllqEmitter<A, B>,
7101    {
7102        <Self as SsePsllqEmitter<A, B>>::sse_psllq(self, op0, op1);
7103    }
7104    /// `SSE_PSLLW`.
7105    ///
7106    /// Supported operand variants:
7107    ///
7108    /// ```text
7109    /// +---+----------+
7110    /// | # | Operands |
7111    /// +---+----------+
7112    /// | 1 | Xmm, Imm |
7113    /// | 2 | Xmm, Mem |
7114    /// | 3 | Xmm, Xmm |
7115    /// +---+----------+
7116    /// ```
7117    #[inline]
7118    pub fn sse_psllw<A, B>(&mut self, op0: A, op1: B)
7119    where
7120        Assembler<'a>: SsePsllwEmitter<A, B>,
7121    {
7122        <Self as SsePsllwEmitter<A, B>>::sse_psllw(self, op0, op1);
7123    }
7124    /// `SSE_PSRAD`.
7125    ///
7126    /// Supported operand variants:
7127    ///
7128    /// ```text
7129    /// +---+----------+
7130    /// | # | Operands |
7131    /// +---+----------+
7132    /// | 1 | Xmm, Imm |
7133    /// | 2 | Xmm, Mem |
7134    /// | 3 | Xmm, Xmm |
7135    /// +---+----------+
7136    /// ```
7137    #[inline]
7138    pub fn sse_psrad<A, B>(&mut self, op0: A, op1: B)
7139    where
7140        Assembler<'a>: SsePsradEmitter<A, B>,
7141    {
7142        <Self as SsePsradEmitter<A, B>>::sse_psrad(self, op0, op1);
7143    }
7144    /// `SSE_PSRAW`.
7145    ///
7146    /// Supported operand variants:
7147    ///
7148    /// ```text
7149    /// +---+----------+
7150    /// | # | Operands |
7151    /// +---+----------+
7152    /// | 1 | Xmm, Imm |
7153    /// | 2 | Xmm, Mem |
7154    /// | 3 | Xmm, Xmm |
7155    /// +---+----------+
7156    /// ```
7157    #[inline]
7158    pub fn sse_psraw<A, B>(&mut self, op0: A, op1: B)
7159    where
7160        Assembler<'a>: SsePsrawEmitter<A, B>,
7161    {
7162        <Self as SsePsrawEmitter<A, B>>::sse_psraw(self, op0, op1);
7163    }
7164    /// `SSE_PSRLD`.
7165    ///
7166    /// Supported operand variants:
7167    ///
7168    /// ```text
7169    /// +---+----------+
7170    /// | # | Operands |
7171    /// +---+----------+
7172    /// | 1 | Xmm, Imm |
7173    /// | 2 | Xmm, Mem |
7174    /// | 3 | Xmm, Xmm |
7175    /// +---+----------+
7176    /// ```
7177    #[inline]
7178    pub fn sse_psrld<A, B>(&mut self, op0: A, op1: B)
7179    where
7180        Assembler<'a>: SsePsrldEmitter<A, B>,
7181    {
7182        <Self as SsePsrldEmitter<A, B>>::sse_psrld(self, op0, op1);
7183    }
7184    /// `SSE_PSRLDQ`.
7185    ///
7186    /// Supported operand variants:
7187    ///
7188    /// ```text
7189    /// +---+----------+
7190    /// | # | Operands |
7191    /// +---+----------+
7192    /// | 1 | Xmm, Imm |
7193    /// +---+----------+
7194    /// ```
7195    #[inline]
7196    pub fn sse_psrldq<A, B>(&mut self, op0: A, op1: B)
7197    where
7198        Assembler<'a>: SsePsrldqEmitter<A, B>,
7199    {
7200        <Self as SsePsrldqEmitter<A, B>>::sse_psrldq(self, op0, op1);
7201    }
7202    /// `SSE_PSRLQ`.
7203    ///
7204    /// Supported operand variants:
7205    ///
7206    /// ```text
7207    /// +---+----------+
7208    /// | # | Operands |
7209    /// +---+----------+
7210    /// | 1 | Xmm, Imm |
7211    /// | 2 | Xmm, Mem |
7212    /// | 3 | Xmm, Xmm |
7213    /// +---+----------+
7214    /// ```
7215    #[inline]
7216    pub fn sse_psrlq<A, B>(&mut self, op0: A, op1: B)
7217    where
7218        Assembler<'a>: SsePsrlqEmitter<A, B>,
7219    {
7220        <Self as SsePsrlqEmitter<A, B>>::sse_psrlq(self, op0, op1);
7221    }
7222    /// `SSE_PSRLW`.
7223    ///
7224    /// Supported operand variants:
7225    ///
7226    /// ```text
7227    /// +---+----------+
7228    /// | # | Operands |
7229    /// +---+----------+
7230    /// | 1 | Xmm, Imm |
7231    /// | 2 | Xmm, Mem |
7232    /// | 3 | Xmm, Xmm |
7233    /// +---+----------+
7234    /// ```
7235    #[inline]
7236    pub fn sse_psrlw<A, B>(&mut self, op0: A, op1: B)
7237    where
7238        Assembler<'a>: SsePsrlwEmitter<A, B>,
7239    {
7240        <Self as SsePsrlwEmitter<A, B>>::sse_psrlw(self, op0, op1);
7241    }
7242    /// `SSE_PSUBB`.
7243    ///
7244    /// Supported operand variants:
7245    ///
7246    /// ```text
7247    /// +---+----------+
7248    /// | # | Operands |
7249    /// +---+----------+
7250    /// | 1 | Xmm, Mem |
7251    /// | 2 | Xmm, Xmm |
7252    /// +---+----------+
7253    /// ```
7254    #[inline]
7255    pub fn sse_psubb<A, B>(&mut self, op0: A, op1: B)
7256    where
7257        Assembler<'a>: SsePsubbEmitter<A, B>,
7258    {
7259        <Self as SsePsubbEmitter<A, B>>::sse_psubb(self, op0, op1);
7260    }
7261    /// `SSE_PSUBD`.
7262    ///
7263    /// Supported operand variants:
7264    ///
7265    /// ```text
7266    /// +---+----------+
7267    /// | # | Operands |
7268    /// +---+----------+
7269    /// | 1 | Xmm, Mem |
7270    /// | 2 | Xmm, Xmm |
7271    /// +---+----------+
7272    /// ```
7273    #[inline]
7274    pub fn sse_psubd<A, B>(&mut self, op0: A, op1: B)
7275    where
7276        Assembler<'a>: SsePsubdEmitter<A, B>,
7277    {
7278        <Self as SsePsubdEmitter<A, B>>::sse_psubd(self, op0, op1);
7279    }
7280    /// `SSE_PSUBQ`.
7281    ///
7282    /// Supported operand variants:
7283    ///
7284    /// ```text
7285    /// +---+----------+
7286    /// | # | Operands |
7287    /// +---+----------+
7288    /// | 1 | Xmm, Mem |
7289    /// | 2 | Xmm, Xmm |
7290    /// +---+----------+
7291    /// ```
7292    #[inline]
7293    pub fn sse_psubq<A, B>(&mut self, op0: A, op1: B)
7294    where
7295        Assembler<'a>: SsePsubqEmitter<A, B>,
7296    {
7297        <Self as SsePsubqEmitter<A, B>>::sse_psubq(self, op0, op1);
7298    }
7299    /// `SSE_PSUBSB`.
7300    ///
7301    /// Supported operand variants:
7302    ///
7303    /// ```text
7304    /// +---+----------+
7305    /// | # | Operands |
7306    /// +---+----------+
7307    /// | 1 | Xmm, Mem |
7308    /// | 2 | Xmm, Xmm |
7309    /// +---+----------+
7310    /// ```
7311    #[inline]
7312    pub fn sse_psubsb<A, B>(&mut self, op0: A, op1: B)
7313    where
7314        Assembler<'a>: SsePsubsbEmitter<A, B>,
7315    {
7316        <Self as SsePsubsbEmitter<A, B>>::sse_psubsb(self, op0, op1);
7317    }
7318    /// `SSE_PSUBSW`.
7319    ///
7320    /// Supported operand variants:
7321    ///
7322    /// ```text
7323    /// +---+----------+
7324    /// | # | Operands |
7325    /// +---+----------+
7326    /// | 1 | Xmm, Mem |
7327    /// | 2 | Xmm, Xmm |
7328    /// +---+----------+
7329    /// ```
7330    #[inline]
7331    pub fn sse_psubsw<A, B>(&mut self, op0: A, op1: B)
7332    where
7333        Assembler<'a>: SsePsubswEmitter<A, B>,
7334    {
7335        <Self as SsePsubswEmitter<A, B>>::sse_psubsw(self, op0, op1);
7336    }
7337    /// `SSE_PSUBUSB`.
7338    ///
7339    /// Supported operand variants:
7340    ///
7341    /// ```text
7342    /// +---+----------+
7343    /// | # | Operands |
7344    /// +---+----------+
7345    /// | 1 | Xmm, Mem |
7346    /// | 2 | Xmm, Xmm |
7347    /// +---+----------+
7348    /// ```
7349    #[inline]
7350    pub fn sse_psubusb<A, B>(&mut self, op0: A, op1: B)
7351    where
7352        Assembler<'a>: SsePsubusbEmitter<A, B>,
7353    {
7354        <Self as SsePsubusbEmitter<A, B>>::sse_psubusb(self, op0, op1);
7355    }
7356    /// `SSE_PSUBUSW`.
7357    ///
7358    /// Supported operand variants:
7359    ///
7360    /// ```text
7361    /// +---+----------+
7362    /// | # | Operands |
7363    /// +---+----------+
7364    /// | 1 | Xmm, Mem |
7365    /// | 2 | Xmm, Xmm |
7366    /// +---+----------+
7367    /// ```
7368    #[inline]
7369    pub fn sse_psubusw<A, B>(&mut self, op0: A, op1: B)
7370    where
7371        Assembler<'a>: SsePsubuswEmitter<A, B>,
7372    {
7373        <Self as SsePsubuswEmitter<A, B>>::sse_psubusw(self, op0, op1);
7374    }
7375    /// `SSE_PSUBW`.
7376    ///
7377    /// Supported operand variants:
7378    ///
7379    /// ```text
7380    /// +---+----------+
7381    /// | # | Operands |
7382    /// +---+----------+
7383    /// | 1 | Xmm, Mem |
7384    /// | 2 | Xmm, Xmm |
7385    /// +---+----------+
7386    /// ```
7387    #[inline]
7388    pub fn sse_psubw<A, B>(&mut self, op0: A, op1: B)
7389    where
7390        Assembler<'a>: SsePsubwEmitter<A, B>,
7391    {
7392        <Self as SsePsubwEmitter<A, B>>::sse_psubw(self, op0, op1);
7393    }
7394    /// `SSE_PUNPCKHBW`.
7395    ///
7396    /// Supported operand variants:
7397    ///
7398    /// ```text
7399    /// +---+----------+
7400    /// | # | Operands |
7401    /// +---+----------+
7402    /// | 1 | Xmm, Mem |
7403    /// | 2 | Xmm, Xmm |
7404    /// +---+----------+
7405    /// ```
7406    #[inline]
7407    pub fn sse_punpckhbw<A, B>(&mut self, op0: A, op1: B)
7408    where
7409        Assembler<'a>: SsePunpckhbwEmitter<A, B>,
7410    {
7411        <Self as SsePunpckhbwEmitter<A, B>>::sse_punpckhbw(self, op0, op1);
7412    }
7413    /// `SSE_PUNPCKHDQ`.
7414    ///
7415    /// Supported operand variants:
7416    ///
7417    /// ```text
7418    /// +---+----------+
7419    /// | # | Operands |
7420    /// +---+----------+
7421    /// | 1 | Xmm, Mem |
7422    /// | 2 | Xmm, Xmm |
7423    /// +---+----------+
7424    /// ```
7425    #[inline]
7426    pub fn sse_punpckhdq<A, B>(&mut self, op0: A, op1: B)
7427    where
7428        Assembler<'a>: SsePunpckhdqEmitter<A, B>,
7429    {
7430        <Self as SsePunpckhdqEmitter<A, B>>::sse_punpckhdq(self, op0, op1);
7431    }
7432    /// `SSE_PUNPCKHQDQ`.
7433    ///
7434    /// Supported operand variants:
7435    ///
7436    /// ```text
7437    /// +---+----------+
7438    /// | # | Operands |
7439    /// +---+----------+
7440    /// | 1 | Xmm, Mem |
7441    /// | 2 | Xmm, Xmm |
7442    /// +---+----------+
7443    /// ```
7444    #[inline]
7445    pub fn sse_punpckhqdq<A, B>(&mut self, op0: A, op1: B)
7446    where
7447        Assembler<'a>: SsePunpckhqdqEmitter<A, B>,
7448    {
7449        <Self as SsePunpckhqdqEmitter<A, B>>::sse_punpckhqdq(self, op0, op1);
7450    }
7451    /// `SSE_PUNPCKHWD`.
7452    ///
7453    /// Supported operand variants:
7454    ///
7455    /// ```text
7456    /// +---+----------+
7457    /// | # | Operands |
7458    /// +---+----------+
7459    /// | 1 | Xmm, Mem |
7460    /// | 2 | Xmm, Xmm |
7461    /// +---+----------+
7462    /// ```
7463    #[inline]
7464    pub fn sse_punpckhwd<A, B>(&mut self, op0: A, op1: B)
7465    where
7466        Assembler<'a>: SsePunpckhwdEmitter<A, B>,
7467    {
7468        <Self as SsePunpckhwdEmitter<A, B>>::sse_punpckhwd(self, op0, op1);
7469    }
7470    /// `SSE_PUNPCKLBW`.
7471    ///
7472    /// Supported operand variants:
7473    ///
7474    /// ```text
7475    /// +---+----------+
7476    /// | # | Operands |
7477    /// +---+----------+
7478    /// | 1 | Xmm, Mem |
7479    /// | 2 | Xmm, Xmm |
7480    /// +---+----------+
7481    /// ```
7482    #[inline]
7483    pub fn sse_punpcklbw<A, B>(&mut self, op0: A, op1: B)
7484    where
7485        Assembler<'a>: SsePunpcklbwEmitter<A, B>,
7486    {
7487        <Self as SsePunpcklbwEmitter<A, B>>::sse_punpcklbw(self, op0, op1);
7488    }
7489    /// `SSE_PUNPCKLDQ`.
7490    ///
7491    /// Supported operand variants:
7492    ///
7493    /// ```text
7494    /// +---+----------+
7495    /// | # | Operands |
7496    /// +---+----------+
7497    /// | 1 | Xmm, Mem |
7498    /// | 2 | Xmm, Xmm |
7499    /// +---+----------+
7500    /// ```
7501    #[inline]
7502    pub fn sse_punpckldq<A, B>(&mut self, op0: A, op1: B)
7503    where
7504        Assembler<'a>: SsePunpckldqEmitter<A, B>,
7505    {
7506        <Self as SsePunpckldqEmitter<A, B>>::sse_punpckldq(self, op0, op1);
7507    }
7508    /// `SSE_PUNPCKLQDQ`.
7509    ///
7510    /// Supported operand variants:
7511    ///
7512    /// ```text
7513    /// +---+----------+
7514    /// | # | Operands |
7515    /// +---+----------+
7516    /// | 1 | Xmm, Mem |
7517    /// | 2 | Xmm, Xmm |
7518    /// +---+----------+
7519    /// ```
7520    #[inline]
7521    pub fn sse_punpcklqdq<A, B>(&mut self, op0: A, op1: B)
7522    where
7523        Assembler<'a>: SsePunpcklqdqEmitter<A, B>,
7524    {
7525        <Self as SsePunpcklqdqEmitter<A, B>>::sse_punpcklqdq(self, op0, op1);
7526    }
7527    /// `SSE_PUNPCKLWD`.
7528    ///
7529    /// Supported operand variants:
7530    ///
7531    /// ```text
7532    /// +---+----------+
7533    /// | # | Operands |
7534    /// +---+----------+
7535    /// | 1 | Xmm, Mem |
7536    /// | 2 | Xmm, Xmm |
7537    /// +---+----------+
7538    /// ```
7539    #[inline]
7540    pub fn sse_punpcklwd<A, B>(&mut self, op0: A, op1: B)
7541    where
7542        Assembler<'a>: SsePunpcklwdEmitter<A, B>,
7543    {
7544        <Self as SsePunpcklwdEmitter<A, B>>::sse_punpcklwd(self, op0, op1);
7545    }
7546    /// `SSE_PXOR`.
7547    ///
7548    /// Supported operand variants:
7549    ///
7550    /// ```text
7551    /// +---+----------+
7552    /// | # | Operands |
7553    /// +---+----------+
7554    /// | 1 | Xmm, Mem |
7555    /// | 2 | Xmm, Xmm |
7556    /// +---+----------+
7557    /// ```
7558    #[inline]
7559    pub fn sse_pxor<A, B>(&mut self, op0: A, op1: B)
7560    where
7561        Assembler<'a>: SsePxorEmitter<A, B>,
7562    {
7563        <Self as SsePxorEmitter<A, B>>::sse_pxor(self, op0, op1);
7564    }
7565    /// `SSE_SHUFPD`.
7566    ///
7567    /// Supported operand variants:
7568    ///
7569    /// ```text
7570    /// +---+---------------+
7571    /// | # | Operands      |
7572    /// +---+---------------+
7573    /// | 1 | Xmm, Mem, Imm |
7574    /// | 2 | Xmm, Xmm, Imm |
7575    /// +---+---------------+
7576    /// ```
7577    #[inline]
7578    pub fn sse_shufpd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
7579    where
7580        Assembler<'a>: SseShufpdEmitter<A, B, C>,
7581    {
7582        <Self as SseShufpdEmitter<A, B, C>>::sse_shufpd(self, op0, op1, op2);
7583    }
7584    /// `SSE_SQRTPD`.
7585    ///
7586    /// Supported operand variants:
7587    ///
7588    /// ```text
7589    /// +---+----------+
7590    /// | # | Operands |
7591    /// +---+----------+
7592    /// | 1 | Xmm, Mem |
7593    /// | 2 | Xmm, Xmm |
7594    /// +---+----------+
7595    /// ```
7596    #[inline]
7597    pub fn sse_sqrtpd<A, B>(&mut self, op0: A, op1: B)
7598    where
7599        Assembler<'a>: SseSqrtpdEmitter<A, B>,
7600    {
7601        <Self as SseSqrtpdEmitter<A, B>>::sse_sqrtpd(self, op0, op1);
7602    }
7603    /// `SSE_SQRTSD`.
7604    ///
7605    /// Supported operand variants:
7606    ///
7607    /// ```text
7608    /// +---+----------+
7609    /// | # | Operands |
7610    /// +---+----------+
7611    /// | 1 | Xmm, Mem |
7612    /// | 2 | Xmm, Xmm |
7613    /// +---+----------+
7614    /// ```
7615    #[inline]
7616    pub fn sse_sqrtsd<A, B>(&mut self, op0: A, op1: B)
7617    where
7618        Assembler<'a>: SseSqrtsdEmitter<A, B>,
7619    {
7620        <Self as SseSqrtsdEmitter<A, B>>::sse_sqrtsd(self, op0, op1);
7621    }
7622    /// `SSE_SUBPD`.
7623    ///
7624    /// Supported operand variants:
7625    ///
7626    /// ```text
7627    /// +---+----------+
7628    /// | # | Operands |
7629    /// +---+----------+
7630    /// | 1 | Xmm, Mem |
7631    /// | 2 | Xmm, Xmm |
7632    /// +---+----------+
7633    /// ```
7634    #[inline]
7635    pub fn sse_subpd<A, B>(&mut self, op0: A, op1: B)
7636    where
7637        Assembler<'a>: SseSubpdEmitter<A, B>,
7638    {
7639        <Self as SseSubpdEmitter<A, B>>::sse_subpd(self, op0, op1);
7640    }
7641    /// `SSE_SUBSD`.
7642    ///
7643    /// Supported operand variants:
7644    ///
7645    /// ```text
7646    /// +---+----------+
7647    /// | # | Operands |
7648    /// +---+----------+
7649    /// | 1 | Xmm, Mem |
7650    /// | 2 | Xmm, Xmm |
7651    /// +---+----------+
7652    /// ```
7653    #[inline]
7654    pub fn sse_subsd<A, B>(&mut self, op0: A, op1: B)
7655    where
7656        Assembler<'a>: SseSubsdEmitter<A, B>,
7657    {
7658        <Self as SseSubsdEmitter<A, B>>::sse_subsd(self, op0, op1);
7659    }
7660    /// `SSE_UCOMISD`.
7661    ///
7662    /// Supported operand variants:
7663    ///
7664    /// ```text
7665    /// +---+----------+
7666    /// | # | Operands |
7667    /// +---+----------+
7668    /// | 1 | Xmm, Mem |
7669    /// | 2 | Xmm, Xmm |
7670    /// +---+----------+
7671    /// ```
7672    #[inline]
7673    pub fn sse_ucomisd<A, B>(&mut self, op0: A, op1: B)
7674    where
7675        Assembler<'a>: SseUcomisdEmitter<A, B>,
7676    {
7677        <Self as SseUcomisdEmitter<A, B>>::sse_ucomisd(self, op0, op1);
7678    }
7679    /// `SSE_UNPCKHPD`.
7680    ///
7681    /// Supported operand variants:
7682    ///
7683    /// ```text
7684    /// +---+----------+
7685    /// | # | Operands |
7686    /// +---+----------+
7687    /// | 1 | Xmm, Mem |
7688    /// | 2 | Xmm, Xmm |
7689    /// +---+----------+
7690    /// ```
7691    #[inline]
7692    pub fn sse_unpckhpd<A, B>(&mut self, op0: A, op1: B)
7693    where
7694        Assembler<'a>: SseUnpckhpdEmitter<A, B>,
7695    {
7696        <Self as SseUnpckhpdEmitter<A, B>>::sse_unpckhpd(self, op0, op1);
7697    }
7698    /// `SSE_UNPCKLPD`.
7699    ///
7700    /// Supported operand variants:
7701    ///
7702    /// ```text
7703    /// +---+----------+
7704    /// | # | Operands |
7705    /// +---+----------+
7706    /// | 1 | Xmm, Mem |
7707    /// | 2 | Xmm, Xmm |
7708    /// +---+----------+
7709    /// ```
7710    #[inline]
7711    pub fn sse_unpcklpd<A, B>(&mut self, op0: A, op1: B)
7712    where
7713        Assembler<'a>: SseUnpcklpdEmitter<A, B>,
7714    {
7715        <Self as SseUnpcklpdEmitter<A, B>>::sse_unpcklpd(self, op0, op1);
7716    }
7717    /// `SSE_XORPD`.
7718    ///
7719    /// Supported operand variants:
7720    ///
7721    /// ```text
7722    /// +---+----------+
7723    /// | # | Operands |
7724    /// +---+----------+
7725    /// | 1 | Xmm, Mem |
7726    /// | 2 | Xmm, Xmm |
7727    /// +---+----------+
7728    /// ```
7729    #[inline]
7730    pub fn sse_xorpd<A, B>(&mut self, op0: A, op1: B)
7731    where
7732        Assembler<'a>: SseXorpdEmitter<A, B>,
7733    {
7734        <Self as SseXorpdEmitter<A, B>>::sse_xorpd(self, op0, op1);
7735    }
7736}
asmkit/x86/features/SSE2.rs

asmkit/x86/features/
SSE2.rs
