asmkit/x86/features/
SSE41.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/// `SSE_BLENDPD`.
11///
12/// Supported operand variants:
13///
14/// ```text
15/// +---+---------------+
16/// | # | Operands      |
17/// +---+---------------+
18/// | 1 | Xmm, Mem, Imm |
19/// | 2 | Xmm, Xmm, Imm |
20/// +---+---------------+
21/// ```
22pub trait SseBlendpdEmitter<A, B, C> {
23    fn sse_blendpd(&mut self, op0: A, op1: B, op2: C);
24}
25
26impl<'a> SseBlendpdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
27    fn sse_blendpd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
28        self.emit(
29            SSE_BLENDPDRRI,
30            op0.as_operand(),
31            op1.as_operand(),
32            op2.as_operand(),
33            &NOREG,
34        );
35    }
36}
37
38impl<'a> SseBlendpdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
39    fn sse_blendpd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
40        self.emit(
41            SSE_BLENDPDRMI,
42            op0.as_operand(),
43            op1.as_operand(),
44            op2.as_operand(),
45            &NOREG,
46        );
47    }
48}
49
50/// `SSE_BLENDPS`.
51///
52/// Supported operand variants:
53///
54/// ```text
55/// +---+---------------+
56/// | # | Operands      |
57/// +---+---------------+
58/// | 1 | Xmm, Mem, Imm |
59/// | 2 | Xmm, Xmm, Imm |
60/// +---+---------------+
61/// ```
62pub trait SseBlendpsEmitter<A, B, C> {
63    fn sse_blendps(&mut self, op0: A, op1: B, op2: C);
64}
65
66impl<'a> SseBlendpsEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
67    fn sse_blendps(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
68        self.emit(
69            SSE_BLENDPSRRI,
70            op0.as_operand(),
71            op1.as_operand(),
72            op2.as_operand(),
73            &NOREG,
74        );
75    }
76}
77
78impl<'a> SseBlendpsEmitter<Xmm, Mem, Imm> for Assembler<'a> {
79    fn sse_blendps(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
80        self.emit(
81            SSE_BLENDPSRMI,
82            op0.as_operand(),
83            op1.as_operand(),
84            op2.as_operand(),
85            &NOREG,
86        );
87    }
88}
89
90/// `SSE_BLENDVPD`.
91///
92/// Supported operand variants:
93///
94/// ```text
95/// +---+---------------+
96/// | # | Operands      |
97/// +---+---------------+
98/// | 1 | Xmm, Mem, Xmm |
99/// | 2 | Xmm, Xmm, Xmm |
100/// +---+---------------+
101/// ```
102pub trait SseBlendvpdEmitter<A, B, C> {
103    fn sse_blendvpd(&mut self, op0: A, op1: B, op2: C);
104}
105
106impl<'a> SseBlendvpdEmitter<Xmm, Xmm, Xmm> for Assembler<'a> {
107    fn sse_blendvpd(&mut self, op0: Xmm, op1: Xmm, op2: Xmm) {
108        self.emit(
109            SSE_BLENDVPDRRR,
110            op0.as_operand(),
111            op1.as_operand(),
112            op2.as_operand(),
113            &NOREG,
114        );
115    }
116}
117
118impl<'a> SseBlendvpdEmitter<Xmm, Mem, Xmm> for Assembler<'a> {
119    fn sse_blendvpd(&mut self, op0: Xmm, op1: Mem, op2: Xmm) {
120        self.emit(
121            SSE_BLENDVPDRMR,
122            op0.as_operand(),
123            op1.as_operand(),
124            op2.as_operand(),
125            &NOREG,
126        );
127    }
128}
129
130/// `SSE_BLENDVPS`.
131///
132/// Supported operand variants:
133///
134/// ```text
135/// +---+---------------+
136/// | # | Operands      |
137/// +---+---------------+
138/// | 1 | Xmm, Mem, Xmm |
139/// | 2 | Xmm, Xmm, Xmm |
140/// +---+---------------+
141/// ```
142pub trait SseBlendvpsEmitter<A, B, C> {
143    fn sse_blendvps(&mut self, op0: A, op1: B, op2: C);
144}
145
146impl<'a> SseBlendvpsEmitter<Xmm, Xmm, Xmm> for Assembler<'a> {
147    fn sse_blendvps(&mut self, op0: Xmm, op1: Xmm, op2: Xmm) {
148        self.emit(
149            SSE_BLENDVPSRRR,
150            op0.as_operand(),
151            op1.as_operand(),
152            op2.as_operand(),
153            &NOREG,
154        );
155    }
156}
157
158impl<'a> SseBlendvpsEmitter<Xmm, Mem, Xmm> for Assembler<'a> {
159    fn sse_blendvps(&mut self, op0: Xmm, op1: Mem, op2: Xmm) {
160        self.emit(
161            SSE_BLENDVPSRMR,
162            op0.as_operand(),
163            op1.as_operand(),
164            op2.as_operand(),
165            &NOREG,
166        );
167    }
168}
169
170/// `SSE_DPPD`.
171///
172/// Supported operand variants:
173///
174/// ```text
175/// +---+---------------+
176/// | # | Operands      |
177/// +---+---------------+
178/// | 1 | Xmm, Mem, Imm |
179/// | 2 | Xmm, Xmm, Imm |
180/// +---+---------------+
181/// ```
182pub trait SseDppdEmitter<A, B, C> {
183    fn sse_dppd(&mut self, op0: A, op1: B, op2: C);
184}
185
186impl<'a> SseDppdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
187    fn sse_dppd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
188        self.emit(
189            SSE_DPPDRRI,
190            op0.as_operand(),
191            op1.as_operand(),
192            op2.as_operand(),
193            &NOREG,
194        );
195    }
196}
197
198impl<'a> SseDppdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
199    fn sse_dppd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
200        self.emit(
201            SSE_DPPDRMI,
202            op0.as_operand(),
203            op1.as_operand(),
204            op2.as_operand(),
205            &NOREG,
206        );
207    }
208}
209
210/// `SSE_DPPS`.
211///
212/// Supported operand variants:
213///
214/// ```text
215/// +---+---------------+
216/// | # | Operands      |
217/// +---+---------------+
218/// | 1 | Xmm, Mem, Imm |
219/// | 2 | Xmm, Xmm, Imm |
220/// +---+---------------+
221/// ```
222pub trait SseDppsEmitter<A, B, C> {
223    fn sse_dpps(&mut self, op0: A, op1: B, op2: C);
224}
225
226impl<'a> SseDppsEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
227    fn sse_dpps(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
228        self.emit(
229            SSE_DPPSRRI,
230            op0.as_operand(),
231            op1.as_operand(),
232            op2.as_operand(),
233            &NOREG,
234        );
235    }
236}
237
238impl<'a> SseDppsEmitter<Xmm, Mem, Imm> for Assembler<'a> {
239    fn sse_dpps(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
240        self.emit(
241            SSE_DPPSRMI,
242            op0.as_operand(),
243            op1.as_operand(),
244            op2.as_operand(),
245            &NOREG,
246        );
247    }
248}
249
250/// `SSE_EXTRACTPS`.
251///
252/// Supported operand variants:
253///
254/// ```text
255/// +---+---------------+
256/// | # | Operands      |
257/// +---+---------------+
258/// | 1 | Gpd, Xmm, Imm |
259/// | 2 | Mem, Xmm, Imm |
260/// +---+---------------+
261/// ```
262pub trait SseExtractpsEmitter<A, B, C> {
263    fn sse_extractps(&mut self, op0: A, op1: B, op2: C);
264}
265
266impl<'a> SseExtractpsEmitter<Gpd, Xmm, Imm> for Assembler<'a> {
267    fn sse_extractps(&mut self, op0: Gpd, op1: Xmm, op2: Imm) {
268        self.emit(
269            SSE_EXTRACTPSRRI,
270            op0.as_operand(),
271            op1.as_operand(),
272            op2.as_operand(),
273            &NOREG,
274        );
275    }
276}
277
278impl<'a> SseExtractpsEmitter<Mem, Xmm, Imm> for Assembler<'a> {
279    fn sse_extractps(&mut self, op0: Mem, op1: Xmm, op2: Imm) {
280        self.emit(
281            SSE_EXTRACTPSMRI,
282            op0.as_operand(),
283            op1.as_operand(),
284            op2.as_operand(),
285            &NOREG,
286        );
287    }
288}
289
290/// `SSE_INSERTPS`.
291///
292/// Supported operand variants:
293///
294/// ```text
295/// +---+---------------+
296/// | # | Operands      |
297/// +---+---------------+
298/// | 1 | Xmm, Mem, Imm |
299/// | 2 | Xmm, Xmm, Imm |
300/// +---+---------------+
301/// ```
302pub trait SseInsertpsEmitter<A, B, C> {
303    fn sse_insertps(&mut self, op0: A, op1: B, op2: C);
304}
305
306impl<'a> SseInsertpsEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
307    fn sse_insertps(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
308        self.emit(
309            SSE_INSERTPSRRI,
310            op0.as_operand(),
311            op1.as_operand(),
312            op2.as_operand(),
313            &NOREG,
314        );
315    }
316}
317
318impl<'a> SseInsertpsEmitter<Xmm, Mem, Imm> for Assembler<'a> {
319    fn sse_insertps(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
320        self.emit(
321            SSE_INSERTPSRMI,
322            op0.as_operand(),
323            op1.as_operand(),
324            op2.as_operand(),
325            &NOREG,
326        );
327    }
328}
329
330/// `SSE_MOVNTDQA`.
331///
332/// Supported operand variants:
333///
334/// ```text
335/// +---+----------+
336/// | # | Operands |
337/// +---+----------+
338/// | 1 | Xmm, Mem |
339/// +---+----------+
340/// ```
341pub trait SseMovntdqaEmitter<A, B> {
342    fn sse_movntdqa(&mut self, op0: A, op1: B);
343}
344
345impl<'a> SseMovntdqaEmitter<Xmm, Mem> for Assembler<'a> {
346    fn sse_movntdqa(&mut self, op0: Xmm, op1: Mem) {
347        self.emit(
348            SSE_MOVNTDQARM,
349            op0.as_operand(),
350            op1.as_operand(),
351            &NOREG,
352            &NOREG,
353        );
354    }
355}
356
357/// `SSE_MPSADBW`.
358///
359/// Supported operand variants:
360///
361/// ```text
362/// +---+---------------+
363/// | # | Operands      |
364/// +---+---------------+
365/// | 1 | Xmm, Mem, Imm |
366/// | 2 | Xmm, Xmm, Imm |
367/// +---+---------------+
368/// ```
369pub trait SseMpsadbwEmitter<A, B, C> {
370    fn sse_mpsadbw(&mut self, op0: A, op1: B, op2: C);
371}
372
373impl<'a> SseMpsadbwEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
374    fn sse_mpsadbw(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
375        self.emit(
376            SSE_MPSADBWRRI,
377            op0.as_operand(),
378            op1.as_operand(),
379            op2.as_operand(),
380            &NOREG,
381        );
382    }
383}
384
385impl<'a> SseMpsadbwEmitter<Xmm, Mem, Imm> for Assembler<'a> {
386    fn sse_mpsadbw(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
387        self.emit(
388            SSE_MPSADBWRMI,
389            op0.as_operand(),
390            op1.as_operand(),
391            op2.as_operand(),
392            &NOREG,
393        );
394    }
395}
396
397/// `SSE_PACKUSDW`.
398///
399/// Supported operand variants:
400///
401/// ```text
402/// +---+----------+
403/// | # | Operands |
404/// +---+----------+
405/// | 1 | Xmm, Mem |
406/// | 2 | Xmm, Xmm |
407/// +---+----------+
408/// ```
409pub trait SsePackusdwEmitter<A, B> {
410    fn sse_packusdw(&mut self, op0: A, op1: B);
411}
412
413impl<'a> SsePackusdwEmitter<Xmm, Xmm> for Assembler<'a> {
414    fn sse_packusdw(&mut self, op0: Xmm, op1: Xmm) {
415        self.emit(
416            SSE_PACKUSDWRR,
417            op0.as_operand(),
418            op1.as_operand(),
419            &NOREG,
420            &NOREG,
421        );
422    }
423}
424
425impl<'a> SsePackusdwEmitter<Xmm, Mem> for Assembler<'a> {
426    fn sse_packusdw(&mut self, op0: Xmm, op1: Mem) {
427        self.emit(
428            SSE_PACKUSDWRM,
429            op0.as_operand(),
430            op1.as_operand(),
431            &NOREG,
432            &NOREG,
433        );
434    }
435}
436
437/// `SSE_PBLENDVB`.
438///
439/// Supported operand variants:
440///
441/// ```text
442/// +---+----------+
443/// | # | Operands |
444/// +---+----------+
445/// | 1 | Xmm, Mem |
446/// | 2 | Xmm, Xmm |
447/// +---+----------+
448/// ```
449pub trait SsePblendvbEmitter<A, B> {
450    fn sse_pblendvb(&mut self, op0: A, op1: B);
451}
452
453impl<'a> SsePblendvbEmitter<Xmm, Xmm> for Assembler<'a> {
454    fn sse_pblendvb(&mut self, op0: Xmm, op1: Xmm) {
455        self.emit(
456            SSE_PBLENDVBRR,
457            op0.as_operand(),
458            op1.as_operand(),
459            &NOREG,
460            &NOREG,
461        );
462    }
463}
464
465impl<'a> SsePblendvbEmitter<Xmm, Mem> for Assembler<'a> {
466    fn sse_pblendvb(&mut self, op0: Xmm, op1: Mem) {
467        self.emit(
468            SSE_PBLENDVBRM,
469            op0.as_operand(),
470            op1.as_operand(),
471            &NOREG,
472            &NOREG,
473        );
474    }
475}
476
477/// `SSE_PBLENDW`.
478///
479/// Supported operand variants:
480///
481/// ```text
482/// +---+---------------+
483/// | # | Operands      |
484/// +---+---------------+
485/// | 1 | Xmm, Mem, Imm |
486/// | 2 | Xmm, Xmm, Imm |
487/// +---+---------------+
488/// ```
489pub trait SsePblendwEmitter<A, B, C> {
490    fn sse_pblendw(&mut self, op0: A, op1: B, op2: C);
491}
492
493impl<'a> SsePblendwEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
494    fn sse_pblendw(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
495        self.emit(
496            SSE_PBLENDWRRI,
497            op0.as_operand(),
498            op1.as_operand(),
499            op2.as_operand(),
500            &NOREG,
501        );
502    }
503}
504
505impl<'a> SsePblendwEmitter<Xmm, Mem, Imm> for Assembler<'a> {
506    fn sse_pblendw(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
507        self.emit(
508            SSE_PBLENDWRMI,
509            op0.as_operand(),
510            op1.as_operand(),
511            op2.as_operand(),
512            &NOREG,
513        );
514    }
515}
516
517/// `SSE_PCMPEQQ`.
518///
519/// Supported operand variants:
520///
521/// ```text
522/// +---+----------+
523/// | # | Operands |
524/// +---+----------+
525/// | 1 | Xmm, Mem |
526/// | 2 | Xmm, Xmm |
527/// +---+----------+
528/// ```
529pub trait SsePcmpeqqEmitter<A, B> {
530    fn sse_pcmpeqq(&mut self, op0: A, op1: B);
531}
532
533impl<'a> SsePcmpeqqEmitter<Xmm, Xmm> for Assembler<'a> {
534    fn sse_pcmpeqq(&mut self, op0: Xmm, op1: Xmm) {
535        self.emit(
536            SSE_PCMPEQQRR,
537            op0.as_operand(),
538            op1.as_operand(),
539            &NOREG,
540            &NOREG,
541        );
542    }
543}
544
545impl<'a> SsePcmpeqqEmitter<Xmm, Mem> for Assembler<'a> {
546    fn sse_pcmpeqq(&mut self, op0: Xmm, op1: Mem) {
547        self.emit(
548            SSE_PCMPEQQRM,
549            op0.as_operand(),
550            op1.as_operand(),
551            &NOREG,
552            &NOREG,
553        );
554    }
555}
556
557/// `SSE_PCMPGTQ`.
558///
559/// Supported operand variants:
560///
561/// ```text
562/// +---+----------+
563/// | # | Operands |
564/// +---+----------+
565/// | 1 | Xmm, Mem |
566/// | 2 | Xmm, Xmm |
567/// +---+----------+
568/// ```
569pub trait SsePcmpgtqEmitter<A, B> {
570    fn sse_pcmpgtq(&mut self, op0: A, op1: B);
571}
572
573impl<'a> SsePcmpgtqEmitter<Xmm, Xmm> for Assembler<'a> {
574    fn sse_pcmpgtq(&mut self, op0: Xmm, op1: Xmm) {
575        self.emit(
576            SSE_PCMPGTQRR,
577            op0.as_operand(),
578            op1.as_operand(),
579            &NOREG,
580            &NOREG,
581        );
582    }
583}
584
585impl<'a> SsePcmpgtqEmitter<Xmm, Mem> for Assembler<'a> {
586    fn sse_pcmpgtq(&mut self, op0: Xmm, op1: Mem) {
587        self.emit(
588            SSE_PCMPGTQRM,
589            op0.as_operand(),
590            op1.as_operand(),
591            &NOREG,
592            &NOREG,
593        );
594    }
595}
596
597/// `SSE_PEXTRB`.
598///
599/// Supported operand variants:
600///
601/// ```text
602/// +---+---------------+
603/// | # | Operands      |
604/// +---+---------------+
605/// | 1 | Gpd, Xmm, Imm |
606/// | 2 | Mem, Xmm, Imm |
607/// +---+---------------+
608/// ```
609pub trait SsePextrbEmitter<A, B, C> {
610    fn sse_pextrb(&mut self, op0: A, op1: B, op2: C);
611}
612
613impl<'a> SsePextrbEmitter<Mem, Xmm, Imm> for Assembler<'a> {
614    fn sse_pextrb(&mut self, op0: Mem, op1: Xmm, op2: Imm) {
615        self.emit(
616            SSE_PEXTRBMRI,
617            op0.as_operand(),
618            op1.as_operand(),
619            op2.as_operand(),
620            &NOREG,
621        );
622    }
623}
624
625impl<'a> SsePextrbEmitter<Gpd, Xmm, Imm> for Assembler<'a> {
626    fn sse_pextrb(&mut self, op0: Gpd, op1: Xmm, op2: Imm) {
627        self.emit(
628            SSE_PEXTRBRRI,
629            op0.as_operand(),
630            op1.as_operand(),
631            op2.as_operand(),
632            &NOREG,
633        );
634    }
635}
636
637/// `SSE_PEXTRD`.
638///
639/// Supported operand variants:
640///
641/// ```text
642/// +---+---------------+
643/// | # | Operands      |
644/// +---+---------------+
645/// | 1 | Gpd, Xmm, Imm |
646/// | 2 | Mem, Xmm, Imm |
647/// +---+---------------+
648/// ```
649pub trait SsePextrdEmitter<A, B, C> {
650    fn sse_pextrd(&mut self, op0: A, op1: B, op2: C);
651}
652
653impl<'a> SsePextrdEmitter<Gpd, Xmm, Imm> for Assembler<'a> {
654    fn sse_pextrd(&mut self, op0: Gpd, op1: Xmm, op2: Imm) {
655        self.emit(
656            SSE_PEXTRDRRI,
657            op0.as_operand(),
658            op1.as_operand(),
659            op2.as_operand(),
660            &NOREG,
661        );
662    }
663}
664
665impl<'a> SsePextrdEmitter<Mem, Xmm, Imm> for Assembler<'a> {
666    fn sse_pextrd(&mut self, op0: Mem, op1: Xmm, op2: Imm) {
667        self.emit(
668            SSE_PEXTRDMRI,
669            op0.as_operand(),
670            op1.as_operand(),
671            op2.as_operand(),
672            &NOREG,
673        );
674    }
675}
676
677/// `SSE_PEXTRQ`.
678///
679/// Supported operand variants:
680///
681/// ```text
682/// +---+---------------+
683/// | # | Operands      |
684/// +---+---------------+
685/// | 1 | Gpd, Xmm, Imm |
686/// | 2 | Mem, Xmm, Imm |
687/// +---+---------------+
688/// ```
689pub trait SsePextrqEmitter<A, B, C> {
690    fn sse_pextrq(&mut self, op0: A, op1: B, op2: C);
691}
692
693impl<'a> SsePextrqEmitter<Gpd, Xmm, Imm> for Assembler<'a> {
694    fn sse_pextrq(&mut self, op0: Gpd, op1: Xmm, op2: Imm) {
695        self.emit(
696            SSE_PEXTRQRRI,
697            op0.as_operand(),
698            op1.as_operand(),
699            op2.as_operand(),
700            &NOREG,
701        );
702    }
703}
704
705impl<'a> SsePextrqEmitter<Mem, Xmm, Imm> for Assembler<'a> {
706    fn sse_pextrq(&mut self, op0: Mem, op1: Xmm, op2: Imm) {
707        self.emit(
708            SSE_PEXTRQMRI,
709            op0.as_operand(),
710            op1.as_operand(),
711            op2.as_operand(),
712            &NOREG,
713        );
714    }
715}
716
717/// `SSE_PHMINPOSUW`.
718///
719/// Supported operand variants:
720///
721/// ```text
722/// +---+----------+
723/// | # | Operands |
724/// +---+----------+
725/// | 1 | Xmm, Mem |
726/// | 2 | Xmm, Xmm |
727/// +---+----------+
728/// ```
729pub trait SsePhminposuwEmitter<A, B> {
730    fn sse_phminposuw(&mut self, op0: A, op1: B);
731}
732
733impl<'a> SsePhminposuwEmitter<Xmm, Xmm> for Assembler<'a> {
734    fn sse_phminposuw(&mut self, op0: Xmm, op1: Xmm) {
735        self.emit(
736            SSE_PHMINPOSUWRR,
737            op0.as_operand(),
738            op1.as_operand(),
739            &NOREG,
740            &NOREG,
741        );
742    }
743}
744
745impl<'a> SsePhminposuwEmitter<Xmm, Mem> for Assembler<'a> {
746    fn sse_phminposuw(&mut self, op0: Xmm, op1: Mem) {
747        self.emit(
748            SSE_PHMINPOSUWRM,
749            op0.as_operand(),
750            op1.as_operand(),
751            &NOREG,
752            &NOREG,
753        );
754    }
755}
756
757/// `SSE_PINSRB`.
758///
759/// Supported operand variants:
760///
761/// ```text
762/// +---+---------------+
763/// | # | Operands      |
764/// +---+---------------+
765/// | 1 | Xmm, Gpd, Imm |
766/// | 2 | Xmm, Mem, Imm |
767/// +---+---------------+
768/// ```
769pub trait SsePinsrbEmitter<A, B, C> {
770    fn sse_pinsrb(&mut self, op0: A, op1: B, op2: C);
771}
772
773impl<'a> SsePinsrbEmitter<Xmm, Gpd, Imm> for Assembler<'a> {
774    fn sse_pinsrb(&mut self, op0: Xmm, op1: Gpd, op2: Imm) {
775        self.emit(
776            SSE_PINSRBRRI,
777            op0.as_operand(),
778            op1.as_operand(),
779            op2.as_operand(),
780            &NOREG,
781        );
782    }
783}
784
785impl<'a> SsePinsrbEmitter<Xmm, Mem, Imm> for Assembler<'a> {
786    fn sse_pinsrb(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
787        self.emit(
788            SSE_PINSRBRMI,
789            op0.as_operand(),
790            op1.as_operand(),
791            op2.as_operand(),
792            &NOREG,
793        );
794    }
795}
796
797/// `SSE_PINSRD`.
798///
799/// Supported operand variants:
800///
801/// ```text
802/// +---+---------------+
803/// | # | Operands      |
804/// +---+---------------+
805/// | 1 | Xmm, Gpd, Imm |
806/// | 2 | Xmm, Mem, Imm |
807/// +---+---------------+
808/// ```
809pub trait SsePinsrdEmitter<A, B, C> {
810    fn sse_pinsrd(&mut self, op0: A, op1: B, op2: C);
811}
812
813impl<'a> SsePinsrdEmitter<Xmm, Gpd, Imm> for Assembler<'a> {
814    fn sse_pinsrd(&mut self, op0: Xmm, op1: Gpd, op2: Imm) {
815        self.emit(
816            SSE_PINSRDRRI,
817            op0.as_operand(),
818            op1.as_operand(),
819            op2.as_operand(),
820            &NOREG,
821        );
822    }
823}
824
825impl<'a> SsePinsrdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
826    fn sse_pinsrd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
827        self.emit(
828            SSE_PINSRDRMI,
829            op0.as_operand(),
830            op1.as_operand(),
831            op2.as_operand(),
832            &NOREG,
833        );
834    }
835}
836
837/// `SSE_PINSRQ`.
838///
839/// Supported operand variants:
840///
841/// ```text
842/// +---+---------------+
843/// | # | Operands      |
844/// +---+---------------+
845/// | 1 | Xmm, Gpd, Imm |
846/// | 2 | Xmm, Mem, Imm |
847/// +---+---------------+
848/// ```
849pub trait SsePinsrqEmitter<A, B, C> {
850    fn sse_pinsrq(&mut self, op0: A, op1: B, op2: C);
851}
852
853impl<'a> SsePinsrqEmitter<Xmm, Gpd, Imm> for Assembler<'a> {
854    fn sse_pinsrq(&mut self, op0: Xmm, op1: Gpd, op2: Imm) {
855        self.emit(
856            SSE_PINSRQRRI,
857            op0.as_operand(),
858            op1.as_operand(),
859            op2.as_operand(),
860            &NOREG,
861        );
862    }
863}
864
865impl<'a> SsePinsrqEmitter<Xmm, Mem, Imm> for Assembler<'a> {
866    fn sse_pinsrq(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
867        self.emit(
868            SSE_PINSRQRMI,
869            op0.as_operand(),
870            op1.as_operand(),
871            op2.as_operand(),
872            &NOREG,
873        );
874    }
875}
876
877/// `SSE_PMAXSB`.
878///
879/// Supported operand variants:
880///
881/// ```text
882/// +---+----------+
883/// | # | Operands |
884/// +---+----------+
885/// | 1 | Xmm, Mem |
886/// | 2 | Xmm, Xmm |
887/// +---+----------+
888/// ```
889pub trait SsePmaxsbEmitter<A, B> {
890    fn sse_pmaxsb(&mut self, op0: A, op1: B);
891}
892
893impl<'a> SsePmaxsbEmitter<Xmm, Xmm> for Assembler<'a> {
894    fn sse_pmaxsb(&mut self, op0: Xmm, op1: Xmm) {
895        self.emit(
896            SSE_PMAXSBRR,
897            op0.as_operand(),
898            op1.as_operand(),
899            &NOREG,
900            &NOREG,
901        );
902    }
903}
904
905impl<'a> SsePmaxsbEmitter<Xmm, Mem> for Assembler<'a> {
906    fn sse_pmaxsb(&mut self, op0: Xmm, op1: Mem) {
907        self.emit(
908            SSE_PMAXSBRM,
909            op0.as_operand(),
910            op1.as_operand(),
911            &NOREG,
912            &NOREG,
913        );
914    }
915}
916
917/// `SSE_PMAXSD`.
918///
919/// Supported operand variants:
920///
921/// ```text
922/// +---+----------+
923/// | # | Operands |
924/// +---+----------+
925/// | 1 | Xmm, Mem |
926/// | 2 | Xmm, Xmm |
927/// +---+----------+
928/// ```
929pub trait SsePmaxsdEmitter<A, B> {
930    fn sse_pmaxsd(&mut self, op0: A, op1: B);
931}
932
933impl<'a> SsePmaxsdEmitter<Xmm, Xmm> for Assembler<'a> {
934    fn sse_pmaxsd(&mut self, op0: Xmm, op1: Xmm) {
935        self.emit(
936            SSE_PMAXSDRR,
937            op0.as_operand(),
938            op1.as_operand(),
939            &NOREG,
940            &NOREG,
941        );
942    }
943}
944
945impl<'a> SsePmaxsdEmitter<Xmm, Mem> for Assembler<'a> {
946    fn sse_pmaxsd(&mut self, op0: Xmm, op1: Mem) {
947        self.emit(
948            SSE_PMAXSDRM,
949            op0.as_operand(),
950            op1.as_operand(),
951            &NOREG,
952            &NOREG,
953        );
954    }
955}
956
957/// `SSE_PMAXUD`.
958///
959/// Supported operand variants:
960///
961/// ```text
962/// +---+----------+
963/// | # | Operands |
964/// +---+----------+
965/// | 1 | Xmm, Mem |
966/// | 2 | Xmm, Xmm |
967/// +---+----------+
968/// ```
969pub trait SsePmaxudEmitter<A, B> {
970    fn sse_pmaxud(&mut self, op0: A, op1: B);
971}
972
973impl<'a> SsePmaxudEmitter<Xmm, Xmm> for Assembler<'a> {
974    fn sse_pmaxud(&mut self, op0: Xmm, op1: Xmm) {
975        self.emit(
976            SSE_PMAXUDRR,
977            op0.as_operand(),
978            op1.as_operand(),
979            &NOREG,
980            &NOREG,
981        );
982    }
983}
984
985impl<'a> SsePmaxudEmitter<Xmm, Mem> for Assembler<'a> {
986    fn sse_pmaxud(&mut self, op0: Xmm, op1: Mem) {
987        self.emit(
988            SSE_PMAXUDRM,
989            op0.as_operand(),
990            op1.as_operand(),
991            &NOREG,
992            &NOREG,
993        );
994    }
995}
996
997/// `SSE_PMAXUW`.
998///
999/// Supported operand variants:
1000///
1001/// ```text
1002/// +---+----------+
1003/// | # | Operands |
1004/// +---+----------+
1005/// | 1 | Xmm, Mem |
1006/// | 2 | Xmm, Xmm |
1007/// +---+----------+
1008/// ```
1009pub trait SsePmaxuwEmitter<A, B> {
1010    fn sse_pmaxuw(&mut self, op0: A, op1: B);
1011}
1012
1013impl<'a> SsePmaxuwEmitter<Xmm, Xmm> for Assembler<'a> {
1014    fn sse_pmaxuw(&mut self, op0: Xmm, op1: Xmm) {
1015        self.emit(
1016            SSE_PMAXUWRR,
1017            op0.as_operand(),
1018            op1.as_operand(),
1019            &NOREG,
1020            &NOREG,
1021        );
1022    }
1023}
1024
1025impl<'a> SsePmaxuwEmitter<Xmm, Mem> for Assembler<'a> {
1026    fn sse_pmaxuw(&mut self, op0: Xmm, op1: Mem) {
1027        self.emit(
1028            SSE_PMAXUWRM,
1029            op0.as_operand(),
1030            op1.as_operand(),
1031            &NOREG,
1032            &NOREG,
1033        );
1034    }
1035}
1036
1037/// `SSE_PMINSB`.
1038///
1039/// Supported operand variants:
1040///
1041/// ```text
1042/// +---+----------+
1043/// | # | Operands |
1044/// +---+----------+
1045/// | 1 | Xmm, Mem |
1046/// | 2 | Xmm, Xmm |
1047/// +---+----------+
1048/// ```
1049pub trait SsePminsbEmitter<A, B> {
1050    fn sse_pminsb(&mut self, op0: A, op1: B);
1051}
1052
1053impl<'a> SsePminsbEmitter<Xmm, Xmm> for Assembler<'a> {
1054    fn sse_pminsb(&mut self, op0: Xmm, op1: Xmm) {
1055        self.emit(
1056            SSE_PMINSBRR,
1057            op0.as_operand(),
1058            op1.as_operand(),
1059            &NOREG,
1060            &NOREG,
1061        );
1062    }
1063}
1064
1065impl<'a> SsePminsbEmitter<Xmm, Mem> for Assembler<'a> {
1066    fn sse_pminsb(&mut self, op0: Xmm, op1: Mem) {
1067        self.emit(
1068            SSE_PMINSBRM,
1069            op0.as_operand(),
1070            op1.as_operand(),
1071            &NOREG,
1072            &NOREG,
1073        );
1074    }
1075}
1076
1077/// `SSE_PMINSD`.
1078///
1079/// Supported operand variants:
1080///
1081/// ```text
1082/// +---+----------+
1083/// | # | Operands |
1084/// +---+----------+
1085/// | 1 | Xmm, Mem |
1086/// | 2 | Xmm, Xmm |
1087/// +---+----------+
1088/// ```
1089pub trait SsePminsdEmitter<A, B> {
1090    fn sse_pminsd(&mut self, op0: A, op1: B);
1091}
1092
1093impl<'a> SsePminsdEmitter<Xmm, Xmm> for Assembler<'a> {
1094    fn sse_pminsd(&mut self, op0: Xmm, op1: Xmm) {
1095        self.emit(
1096            SSE_PMINSDRR,
1097            op0.as_operand(),
1098            op1.as_operand(),
1099            &NOREG,
1100            &NOREG,
1101        );
1102    }
1103}
1104
1105impl<'a> SsePminsdEmitter<Xmm, Mem> for Assembler<'a> {
1106    fn sse_pminsd(&mut self, op0: Xmm, op1: Mem) {
1107        self.emit(
1108            SSE_PMINSDRM,
1109            op0.as_operand(),
1110            op1.as_operand(),
1111            &NOREG,
1112            &NOREG,
1113        );
1114    }
1115}
1116
1117/// `SSE_PMINUD`.
1118///
1119/// Supported operand variants:
1120///
1121/// ```text
1122/// +---+----------+
1123/// | # | Operands |
1124/// +---+----------+
1125/// | 1 | Xmm, Mem |
1126/// | 2 | Xmm, Xmm |
1127/// +---+----------+
1128/// ```
1129pub trait SsePminudEmitter<A, B> {
1130    fn sse_pminud(&mut self, op0: A, op1: B);
1131}
1132
1133impl<'a> SsePminudEmitter<Xmm, Xmm> for Assembler<'a> {
1134    fn sse_pminud(&mut self, op0: Xmm, op1: Xmm) {
1135        self.emit(
1136            SSE_PMINUDRR,
1137            op0.as_operand(),
1138            op1.as_operand(),
1139            &NOREG,
1140            &NOREG,
1141        );
1142    }
1143}
1144
1145impl<'a> SsePminudEmitter<Xmm, Mem> for Assembler<'a> {
1146    fn sse_pminud(&mut self, op0: Xmm, op1: Mem) {
1147        self.emit(
1148            SSE_PMINUDRM,
1149            op0.as_operand(),
1150            op1.as_operand(),
1151            &NOREG,
1152            &NOREG,
1153        );
1154    }
1155}
1156
1157/// `SSE_PMINUW`.
1158///
1159/// Supported operand variants:
1160///
1161/// ```text
1162/// +---+----------+
1163/// | # | Operands |
1164/// +---+----------+
1165/// | 1 | Xmm, Mem |
1166/// | 2 | Xmm, Xmm |
1167/// +---+----------+
1168/// ```
1169pub trait SsePminuwEmitter<A, B> {
1170    fn sse_pminuw(&mut self, op0: A, op1: B);
1171}
1172
1173impl<'a> SsePminuwEmitter<Xmm, Xmm> for Assembler<'a> {
1174    fn sse_pminuw(&mut self, op0: Xmm, op1: Xmm) {
1175        self.emit(
1176            SSE_PMINUWRR,
1177            op0.as_operand(),
1178            op1.as_operand(),
1179            &NOREG,
1180            &NOREG,
1181        );
1182    }
1183}
1184
1185impl<'a> SsePminuwEmitter<Xmm, Mem> for Assembler<'a> {
1186    fn sse_pminuw(&mut self, op0: Xmm, op1: Mem) {
1187        self.emit(
1188            SSE_PMINUWRM,
1189            op0.as_operand(),
1190            op1.as_operand(),
1191            &NOREG,
1192            &NOREG,
1193        );
1194    }
1195}
1196
1197/// `SSE_PMOVSXBD`.
1198///
1199/// Supported operand variants:
1200///
1201/// ```text
1202/// +---+----------+
1203/// | # | Operands |
1204/// +---+----------+
1205/// | 1 | Xmm, Mem |
1206/// | 2 | Xmm, Xmm |
1207/// +---+----------+
1208/// ```
1209pub trait SsePmovsxbdEmitter<A, B> {
1210    fn sse_pmovsxbd(&mut self, op0: A, op1: B);
1211}
1212
1213impl<'a> SsePmovsxbdEmitter<Xmm, Xmm> for Assembler<'a> {
1214    fn sse_pmovsxbd(&mut self, op0: Xmm, op1: Xmm) {
1215        self.emit(
1216            SSE_PMOVSXBDRR,
1217            op0.as_operand(),
1218            op1.as_operand(),
1219            &NOREG,
1220            &NOREG,
1221        );
1222    }
1223}
1224
1225impl<'a> SsePmovsxbdEmitter<Xmm, Mem> for Assembler<'a> {
1226    fn sse_pmovsxbd(&mut self, op0: Xmm, op1: Mem) {
1227        self.emit(
1228            SSE_PMOVSXBDRM,
1229            op0.as_operand(),
1230            op1.as_operand(),
1231            &NOREG,
1232            &NOREG,
1233        );
1234    }
1235}
1236
1237/// `SSE_PMOVSXBQ`.
1238///
1239/// Supported operand variants:
1240///
1241/// ```text
1242/// +---+----------+
1243/// | # | Operands |
1244/// +---+----------+
1245/// | 1 | Xmm, Mem |
1246/// | 2 | Xmm, Xmm |
1247/// +---+----------+
1248/// ```
1249pub trait SsePmovsxbqEmitter<A, B> {
1250    fn sse_pmovsxbq(&mut self, op0: A, op1: B);
1251}
1252
1253impl<'a> SsePmovsxbqEmitter<Xmm, Xmm> for Assembler<'a> {
1254    fn sse_pmovsxbq(&mut self, op0: Xmm, op1: Xmm) {
1255        self.emit(
1256            SSE_PMOVSXBQRR,
1257            op0.as_operand(),
1258            op1.as_operand(),
1259            &NOREG,
1260            &NOREG,
1261        );
1262    }
1263}
1264
1265impl<'a> SsePmovsxbqEmitter<Xmm, Mem> for Assembler<'a> {
1266    fn sse_pmovsxbq(&mut self, op0: Xmm, op1: Mem) {
1267        self.emit(
1268            SSE_PMOVSXBQRM,
1269            op0.as_operand(),
1270            op1.as_operand(),
1271            &NOREG,
1272            &NOREG,
1273        );
1274    }
1275}
1276
1277/// `SSE_PMOVSXBW`.
1278///
1279/// Supported operand variants:
1280///
1281/// ```text
1282/// +---+----------+
1283/// | # | Operands |
1284/// +---+----------+
1285/// | 1 | Xmm, Mem |
1286/// | 2 | Xmm, Xmm |
1287/// +---+----------+
1288/// ```
1289pub trait SsePmovsxbwEmitter<A, B> {
1290    fn sse_pmovsxbw(&mut self, op0: A, op1: B);
1291}
1292
1293impl<'a> SsePmovsxbwEmitter<Xmm, Xmm> for Assembler<'a> {
1294    fn sse_pmovsxbw(&mut self, op0: Xmm, op1: Xmm) {
1295        self.emit(
1296            SSE_PMOVSXBWRR,
1297            op0.as_operand(),
1298            op1.as_operand(),
1299            &NOREG,
1300            &NOREG,
1301        );
1302    }
1303}
1304
1305impl<'a> SsePmovsxbwEmitter<Xmm, Mem> for Assembler<'a> {
1306    fn sse_pmovsxbw(&mut self, op0: Xmm, op1: Mem) {
1307        self.emit(
1308            SSE_PMOVSXBWRM,
1309            op0.as_operand(),
1310            op1.as_operand(),
1311            &NOREG,
1312            &NOREG,
1313        );
1314    }
1315}
1316
1317/// `SSE_PMOVSXDQ`.
1318///
1319/// Supported operand variants:
1320///
1321/// ```text
1322/// +---+----------+
1323/// | # | Operands |
1324/// +---+----------+
1325/// | 1 | Xmm, Mem |
1326/// | 2 | Xmm, Xmm |
1327/// +---+----------+
1328/// ```
1329pub trait SsePmovsxdqEmitter<A, B> {
1330    fn sse_pmovsxdq(&mut self, op0: A, op1: B);
1331}
1332
1333impl<'a> SsePmovsxdqEmitter<Xmm, Xmm> for Assembler<'a> {
1334    fn sse_pmovsxdq(&mut self, op0: Xmm, op1: Xmm) {
1335        self.emit(
1336            SSE_PMOVSXDQRR,
1337            op0.as_operand(),
1338            op1.as_operand(),
1339            &NOREG,
1340            &NOREG,
1341        );
1342    }
1343}
1344
1345impl<'a> SsePmovsxdqEmitter<Xmm, Mem> for Assembler<'a> {
1346    fn sse_pmovsxdq(&mut self, op0: Xmm, op1: Mem) {
1347        self.emit(
1348            SSE_PMOVSXDQRM,
1349            op0.as_operand(),
1350            op1.as_operand(),
1351            &NOREG,
1352            &NOREG,
1353        );
1354    }
1355}
1356
1357/// `SSE_PMOVSXWD`.
1358///
1359/// Supported operand variants:
1360///
1361/// ```text
1362/// +---+----------+
1363/// | # | Operands |
1364/// +---+----------+
1365/// | 1 | Xmm, Mem |
1366/// | 2 | Xmm, Xmm |
1367/// +---+----------+
1368/// ```
1369pub trait SsePmovsxwdEmitter<A, B> {
1370    fn sse_pmovsxwd(&mut self, op0: A, op1: B);
1371}
1372
1373impl<'a> SsePmovsxwdEmitter<Xmm, Xmm> for Assembler<'a> {
1374    fn sse_pmovsxwd(&mut self, op0: Xmm, op1: Xmm) {
1375        self.emit(
1376            SSE_PMOVSXWDRR,
1377            op0.as_operand(),
1378            op1.as_operand(),
1379            &NOREG,
1380            &NOREG,
1381        );
1382    }
1383}
1384
1385impl<'a> SsePmovsxwdEmitter<Xmm, Mem> for Assembler<'a> {
1386    fn sse_pmovsxwd(&mut self, op0: Xmm, op1: Mem) {
1387        self.emit(
1388            SSE_PMOVSXWDRM,
1389            op0.as_operand(),
1390            op1.as_operand(),
1391            &NOREG,
1392            &NOREG,
1393        );
1394    }
1395}
1396
1397/// `SSE_PMOVSXWQ`.
1398///
1399/// Supported operand variants:
1400///
1401/// ```text
1402/// +---+----------+
1403/// | # | Operands |
1404/// +---+----------+
1405/// | 1 | Xmm, Mem |
1406/// | 2 | Xmm, Xmm |
1407/// +---+----------+
1408/// ```
1409pub trait SsePmovsxwqEmitter<A, B> {
1410    fn sse_pmovsxwq(&mut self, op0: A, op1: B);
1411}
1412
1413impl<'a> SsePmovsxwqEmitter<Xmm, Xmm> for Assembler<'a> {
1414    fn sse_pmovsxwq(&mut self, op0: Xmm, op1: Xmm) {
1415        self.emit(
1416            SSE_PMOVSXWQRR,
1417            op0.as_operand(),
1418            op1.as_operand(),
1419            &NOREG,
1420            &NOREG,
1421        );
1422    }
1423}
1424
1425impl<'a> SsePmovsxwqEmitter<Xmm, Mem> for Assembler<'a> {
1426    fn sse_pmovsxwq(&mut self, op0: Xmm, op1: Mem) {
1427        self.emit(
1428            SSE_PMOVSXWQRM,
1429            op0.as_operand(),
1430            op1.as_operand(),
1431            &NOREG,
1432            &NOREG,
1433        );
1434    }
1435}
1436
1437/// `SSE_PMOVZXBD`.
1438///
1439/// Supported operand variants:
1440///
1441/// ```text
1442/// +---+----------+
1443/// | # | Operands |
1444/// +---+----------+
1445/// | 1 | Xmm, Mem |
1446/// | 2 | Xmm, Xmm |
1447/// +---+----------+
1448/// ```
1449pub trait SsePmovzxbdEmitter<A, B> {
1450    fn sse_pmovzxbd(&mut self, op0: A, op1: B);
1451}
1452
1453impl<'a> SsePmovzxbdEmitter<Xmm, Xmm> for Assembler<'a> {
1454    fn sse_pmovzxbd(&mut self, op0: Xmm, op1: Xmm) {
1455        self.emit(
1456            SSE_PMOVZXBDRR,
1457            op0.as_operand(),
1458            op1.as_operand(),
1459            &NOREG,
1460            &NOREG,
1461        );
1462    }
1463}
1464
1465impl<'a> SsePmovzxbdEmitter<Xmm, Mem> for Assembler<'a> {
1466    fn sse_pmovzxbd(&mut self, op0: Xmm, op1: Mem) {
1467        self.emit(
1468            SSE_PMOVZXBDRM,
1469            op0.as_operand(),
1470            op1.as_operand(),
1471            &NOREG,
1472            &NOREG,
1473        );
1474    }
1475}
1476
1477/// `SSE_PMOVZXBQ`.
1478///
1479/// Supported operand variants:
1480///
1481/// ```text
1482/// +---+----------+
1483/// | # | Operands |
1484/// +---+----------+
1485/// | 1 | Xmm, Mem |
1486/// | 2 | Xmm, Xmm |
1487/// +---+----------+
1488/// ```
1489pub trait SsePmovzxbqEmitter<A, B> {
1490    fn sse_pmovzxbq(&mut self, op0: A, op1: B);
1491}
1492
1493impl<'a> SsePmovzxbqEmitter<Xmm, Xmm> for Assembler<'a> {
1494    fn sse_pmovzxbq(&mut self, op0: Xmm, op1: Xmm) {
1495        self.emit(
1496            SSE_PMOVZXBQRR,
1497            op0.as_operand(),
1498            op1.as_operand(),
1499            &NOREG,
1500            &NOREG,
1501        );
1502    }
1503}
1504
1505impl<'a> SsePmovzxbqEmitter<Xmm, Mem> for Assembler<'a> {
1506    fn sse_pmovzxbq(&mut self, op0: Xmm, op1: Mem) {
1507        self.emit(
1508            SSE_PMOVZXBQRM,
1509            op0.as_operand(),
1510            op1.as_operand(),
1511            &NOREG,
1512            &NOREG,
1513        );
1514    }
1515}
1516
1517/// `SSE_PMOVZXBW`.
1518///
1519/// Supported operand variants:
1520///
1521/// ```text
1522/// +---+----------+
1523/// | # | Operands |
1524/// +---+----------+
1525/// | 1 | Xmm, Mem |
1526/// | 2 | Xmm, Xmm |
1527/// +---+----------+
1528/// ```
1529pub trait SsePmovzxbwEmitter<A, B> {
1530    fn sse_pmovzxbw(&mut self, op0: A, op1: B);
1531}
1532
1533impl<'a> SsePmovzxbwEmitter<Xmm, Xmm> for Assembler<'a> {
1534    fn sse_pmovzxbw(&mut self, op0: Xmm, op1: Xmm) {
1535        self.emit(
1536            SSE_PMOVZXBWRR,
1537            op0.as_operand(),
1538            op1.as_operand(),
1539            &NOREG,
1540            &NOREG,
1541        );
1542    }
1543}
1544
1545impl<'a> SsePmovzxbwEmitter<Xmm, Mem> for Assembler<'a> {
1546    fn sse_pmovzxbw(&mut self, op0: Xmm, op1: Mem) {
1547        self.emit(
1548            SSE_PMOVZXBWRM,
1549            op0.as_operand(),
1550            op1.as_operand(),
1551            &NOREG,
1552            &NOREG,
1553        );
1554    }
1555}
1556
1557/// `SSE_PMOVZXDQ`.
1558///
1559/// Supported operand variants:
1560///
1561/// ```text
1562/// +---+----------+
1563/// | # | Operands |
1564/// +---+----------+
1565/// | 1 | Xmm, Mem |
1566/// | 2 | Xmm, Xmm |
1567/// +---+----------+
1568/// ```
1569pub trait SsePmovzxdqEmitter<A, B> {
1570    fn sse_pmovzxdq(&mut self, op0: A, op1: B);
1571}
1572
1573impl<'a> SsePmovzxdqEmitter<Xmm, Xmm> for Assembler<'a> {
1574    fn sse_pmovzxdq(&mut self, op0: Xmm, op1: Xmm) {
1575        self.emit(
1576            SSE_PMOVZXDQRR,
1577            op0.as_operand(),
1578            op1.as_operand(),
1579            &NOREG,
1580            &NOREG,
1581        );
1582    }
1583}
1584
1585impl<'a> SsePmovzxdqEmitter<Xmm, Mem> for Assembler<'a> {
1586    fn sse_pmovzxdq(&mut self, op0: Xmm, op1: Mem) {
1587        self.emit(
1588            SSE_PMOVZXDQRM,
1589            op0.as_operand(),
1590            op1.as_operand(),
1591            &NOREG,
1592            &NOREG,
1593        );
1594    }
1595}
1596
1597/// `SSE_PMOVZXWD`.
1598///
1599/// Supported operand variants:
1600///
1601/// ```text
1602/// +---+----------+
1603/// | # | Operands |
1604/// +---+----------+
1605/// | 1 | Xmm, Mem |
1606/// | 2 | Xmm, Xmm |
1607/// +---+----------+
1608/// ```
1609pub trait SsePmovzxwdEmitter<A, B> {
1610    fn sse_pmovzxwd(&mut self, op0: A, op1: B);
1611}
1612
1613impl<'a> SsePmovzxwdEmitter<Xmm, Xmm> for Assembler<'a> {
1614    fn sse_pmovzxwd(&mut self, op0: Xmm, op1: Xmm) {
1615        self.emit(
1616            SSE_PMOVZXWDRR,
1617            op0.as_operand(),
1618            op1.as_operand(),
1619            &NOREG,
1620            &NOREG,
1621        );
1622    }
1623}
1624
1625impl<'a> SsePmovzxwdEmitter<Xmm, Mem> for Assembler<'a> {
1626    fn sse_pmovzxwd(&mut self, op0: Xmm, op1: Mem) {
1627        self.emit(
1628            SSE_PMOVZXWDRM,
1629            op0.as_operand(),
1630            op1.as_operand(),
1631            &NOREG,
1632            &NOREG,
1633        );
1634    }
1635}
1636
1637/// `SSE_PMOVZXWQ`.
1638///
1639/// Supported operand variants:
1640///
1641/// ```text
1642/// +---+----------+
1643/// | # | Operands |
1644/// +---+----------+
1645/// | 1 | Xmm, Mem |
1646/// | 2 | Xmm, Xmm |
1647/// +---+----------+
1648/// ```
1649pub trait SsePmovzxwqEmitter<A, B> {
1650    fn sse_pmovzxwq(&mut self, op0: A, op1: B);
1651}
1652
1653impl<'a> SsePmovzxwqEmitter<Xmm, Xmm> for Assembler<'a> {
1654    fn sse_pmovzxwq(&mut self, op0: Xmm, op1: Xmm) {
1655        self.emit(
1656            SSE_PMOVZXWQRR,
1657            op0.as_operand(),
1658            op1.as_operand(),
1659            &NOREG,
1660            &NOREG,
1661        );
1662    }
1663}
1664
1665impl<'a> SsePmovzxwqEmitter<Xmm, Mem> for Assembler<'a> {
1666    fn sse_pmovzxwq(&mut self, op0: Xmm, op1: Mem) {
1667        self.emit(
1668            SSE_PMOVZXWQRM,
1669            op0.as_operand(),
1670            op1.as_operand(),
1671            &NOREG,
1672            &NOREG,
1673        );
1674    }
1675}
1676
1677/// `SSE_PMULDQ`.
1678///
1679/// Supported operand variants:
1680///
1681/// ```text
1682/// +---+----------+
1683/// | # | Operands |
1684/// +---+----------+
1685/// | 1 | Xmm, Mem |
1686/// | 2 | Xmm, Xmm |
1687/// +---+----------+
1688/// ```
1689pub trait SsePmuldqEmitter<A, B> {
1690    fn sse_pmuldq(&mut self, op0: A, op1: B);
1691}
1692
1693impl<'a> SsePmuldqEmitter<Xmm, Xmm> for Assembler<'a> {
1694    fn sse_pmuldq(&mut self, op0: Xmm, op1: Xmm) {
1695        self.emit(
1696            SSE_PMULDQRR,
1697            op0.as_operand(),
1698            op1.as_operand(),
1699            &NOREG,
1700            &NOREG,
1701        );
1702    }
1703}
1704
1705impl<'a> SsePmuldqEmitter<Xmm, Mem> for Assembler<'a> {
1706    fn sse_pmuldq(&mut self, op0: Xmm, op1: Mem) {
1707        self.emit(
1708            SSE_PMULDQRM,
1709            op0.as_operand(),
1710            op1.as_operand(),
1711            &NOREG,
1712            &NOREG,
1713        );
1714    }
1715}
1716
1717/// `SSE_PMULLD`.
1718///
1719/// Supported operand variants:
1720///
1721/// ```text
1722/// +---+----------+
1723/// | # | Operands |
1724/// +---+----------+
1725/// | 1 | Xmm, Mem |
1726/// | 2 | Xmm, Xmm |
1727/// +---+----------+
1728/// ```
1729pub trait SsePmulldEmitter<A, B> {
1730    fn sse_pmulld(&mut self, op0: A, op1: B);
1731}
1732
1733impl<'a> SsePmulldEmitter<Xmm, Xmm> for Assembler<'a> {
1734    fn sse_pmulld(&mut self, op0: Xmm, op1: Xmm) {
1735        self.emit(
1736            SSE_PMULLDRR,
1737            op0.as_operand(),
1738            op1.as_operand(),
1739            &NOREG,
1740            &NOREG,
1741        );
1742    }
1743}
1744
1745impl<'a> SsePmulldEmitter<Xmm, Mem> for Assembler<'a> {
1746    fn sse_pmulld(&mut self, op0: Xmm, op1: Mem) {
1747        self.emit(
1748            SSE_PMULLDRM,
1749            op0.as_operand(),
1750            op1.as_operand(),
1751            &NOREG,
1752            &NOREG,
1753        );
1754    }
1755}
1756
1757/// `SSE_PTEST`.
1758///
1759/// Supported operand variants:
1760///
1761/// ```text
1762/// +---+----------+
1763/// | # | Operands |
1764/// +---+----------+
1765/// | 1 | Xmm, Mem |
1766/// | 2 | Xmm, Xmm |
1767/// +---+----------+
1768/// ```
1769pub trait SsePtestEmitter<A, B> {
1770    fn sse_ptest(&mut self, op0: A, op1: B);
1771}
1772
1773impl<'a> SsePtestEmitter<Xmm, Xmm> for Assembler<'a> {
1774    fn sse_ptest(&mut self, op0: Xmm, op1: Xmm) {
1775        self.emit(
1776            SSE_PTESTRR,
1777            op0.as_operand(),
1778            op1.as_operand(),
1779            &NOREG,
1780            &NOREG,
1781        );
1782    }
1783}
1784
1785impl<'a> SsePtestEmitter<Xmm, Mem> for Assembler<'a> {
1786    fn sse_ptest(&mut self, op0: Xmm, op1: Mem) {
1787        self.emit(
1788            SSE_PTESTRM,
1789            op0.as_operand(),
1790            op1.as_operand(),
1791            &NOREG,
1792            &NOREG,
1793        );
1794    }
1795}
1796
1797/// `SSE_ROUNDPD`.
1798///
1799/// Supported operand variants:
1800///
1801/// ```text
1802/// +---+---------------+
1803/// | # | Operands      |
1804/// +---+---------------+
1805/// | 1 | Xmm, Mem, Imm |
1806/// | 2 | Xmm, Xmm, Imm |
1807/// +---+---------------+
1808/// ```
1809pub trait SseRoundpdEmitter<A, B, C> {
1810    fn sse_roundpd(&mut self, op0: A, op1: B, op2: C);
1811}
1812
1813impl<'a> SseRoundpdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
1814    fn sse_roundpd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
1815        self.emit(
1816            SSE_ROUNDPDRRI,
1817            op0.as_operand(),
1818            op1.as_operand(),
1819            op2.as_operand(),
1820            &NOREG,
1821        );
1822    }
1823}
1824
1825impl<'a> SseRoundpdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
1826    fn sse_roundpd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
1827        self.emit(
1828            SSE_ROUNDPDRMI,
1829            op0.as_operand(),
1830            op1.as_operand(),
1831            op2.as_operand(),
1832            &NOREG,
1833        );
1834    }
1835}
1836
1837/// `SSE_ROUNDPS`.
1838///
1839/// Supported operand variants:
1840///
1841/// ```text
1842/// +---+---------------+
1843/// | # | Operands      |
1844/// +---+---------------+
1845/// | 1 | Xmm, Mem, Imm |
1846/// | 2 | Xmm, Xmm, Imm |
1847/// +---+---------------+
1848/// ```
1849pub trait SseRoundpsEmitter<A, B, C> {
1850    fn sse_roundps(&mut self, op0: A, op1: B, op2: C);
1851}
1852
1853impl<'a> SseRoundpsEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
1854    fn sse_roundps(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
1855        self.emit(
1856            SSE_ROUNDPSRRI,
1857            op0.as_operand(),
1858            op1.as_operand(),
1859            op2.as_operand(),
1860            &NOREG,
1861        );
1862    }
1863}
1864
1865impl<'a> SseRoundpsEmitter<Xmm, Mem, Imm> for Assembler<'a> {
1866    fn sse_roundps(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
1867        self.emit(
1868            SSE_ROUNDPSRMI,
1869            op0.as_operand(),
1870            op1.as_operand(),
1871            op2.as_operand(),
1872            &NOREG,
1873        );
1874    }
1875}
1876
1877/// `SSE_ROUNDSD`.
1878///
1879/// Supported operand variants:
1880///
1881/// ```text
1882/// +---+---------------+
1883/// | # | Operands      |
1884/// +---+---------------+
1885/// | 1 | Xmm, Mem, Imm |
1886/// | 2 | Xmm, Xmm, Imm |
1887/// +---+---------------+
1888/// ```
1889pub trait SseRoundsdEmitter<A, B, C> {
1890    fn sse_roundsd(&mut self, op0: A, op1: B, op2: C);
1891}
1892
1893impl<'a> SseRoundsdEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
1894    fn sse_roundsd(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
1895        self.emit(
1896            SSE_ROUNDSDRRI,
1897            op0.as_operand(),
1898            op1.as_operand(),
1899            op2.as_operand(),
1900            &NOREG,
1901        );
1902    }
1903}
1904
1905impl<'a> SseRoundsdEmitter<Xmm, Mem, Imm> for Assembler<'a> {
1906    fn sse_roundsd(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
1907        self.emit(
1908            SSE_ROUNDSDRMI,
1909            op0.as_operand(),
1910            op1.as_operand(),
1911            op2.as_operand(),
1912            &NOREG,
1913        );
1914    }
1915}
1916
1917/// `SSE_ROUNDSS`.
1918///
1919/// Supported operand variants:
1920///
1921/// ```text
1922/// +---+---------------+
1923/// | # | Operands      |
1924/// +---+---------------+
1925/// | 1 | Xmm, Mem, Imm |
1926/// | 2 | Xmm, Xmm, Imm |
1927/// +---+---------------+
1928/// ```
1929pub trait SseRoundssEmitter<A, B, C> {
1930    fn sse_roundss(&mut self, op0: A, op1: B, op2: C);
1931}
1932
1933impl<'a> SseRoundssEmitter<Xmm, Xmm, Imm> for Assembler<'a> {
1934    fn sse_roundss(&mut self, op0: Xmm, op1: Xmm, op2: Imm) {
1935        self.emit(
1936            SSE_ROUNDSSRRI,
1937            op0.as_operand(),
1938            op1.as_operand(),
1939            op2.as_operand(),
1940            &NOREG,
1941        );
1942    }
1943}
1944
1945impl<'a> SseRoundssEmitter<Xmm, Mem, Imm> for Assembler<'a> {
1946    fn sse_roundss(&mut self, op0: Xmm, op1: Mem, op2: Imm) {
1947        self.emit(
1948            SSE_ROUNDSSRMI,
1949            op0.as_operand(),
1950            op1.as_operand(),
1951            op2.as_operand(),
1952            &NOREG,
1953        );
1954    }
1955}
1956
1957impl<'a> Assembler<'a> {
1958    /// `SSE_BLENDPD`.
1959    ///
1960    /// Supported operand variants:
1961    ///
1962    /// ```text
1963    /// +---+---------------+
1964    /// | # | Operands      |
1965    /// +---+---------------+
1966    /// | 1 | Xmm, Mem, Imm |
1967    /// | 2 | Xmm, Xmm, Imm |
1968    /// +---+---------------+
1969    /// ```
1970    #[inline]
1971    pub fn sse_blendpd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
1972    where
1973        Assembler<'a>: SseBlendpdEmitter<A, B, C>,
1974    {
1975        <Self as SseBlendpdEmitter<A, B, C>>::sse_blendpd(self, op0, op1, op2);
1976    }
1977    /// `SSE_BLENDPS`.
1978    ///
1979    /// Supported operand variants:
1980    ///
1981    /// ```text
1982    /// +---+---------------+
1983    /// | # | Operands      |
1984    /// +---+---------------+
1985    /// | 1 | Xmm, Mem, Imm |
1986    /// | 2 | Xmm, Xmm, Imm |
1987    /// +---+---------------+
1988    /// ```
1989    #[inline]
1990    pub fn sse_blendps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
1991    where
1992        Assembler<'a>: SseBlendpsEmitter<A, B, C>,
1993    {
1994        <Self as SseBlendpsEmitter<A, B, C>>::sse_blendps(self, op0, op1, op2);
1995    }
1996    /// `SSE_BLENDVPD`.
1997    ///
1998    /// Supported operand variants:
1999    ///
2000    /// ```text
2001    /// +---+---------------+
2002    /// | # | Operands      |
2003    /// +---+---------------+
2004    /// | 1 | Xmm, Mem, Xmm |
2005    /// | 2 | Xmm, Xmm, Xmm |
2006    /// +---+---------------+
2007    /// ```
2008    #[inline]
2009    pub fn sse_blendvpd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2010    where
2011        Assembler<'a>: SseBlendvpdEmitter<A, B, C>,
2012    {
2013        <Self as SseBlendvpdEmitter<A, B, C>>::sse_blendvpd(self, op0, op1, op2);
2014    }
2015    /// `SSE_BLENDVPS`.
2016    ///
2017    /// Supported operand variants:
2018    ///
2019    /// ```text
2020    /// +---+---------------+
2021    /// | # | Operands      |
2022    /// +---+---------------+
2023    /// | 1 | Xmm, Mem, Xmm |
2024    /// | 2 | Xmm, Xmm, Xmm |
2025    /// +---+---------------+
2026    /// ```
2027    #[inline]
2028    pub fn sse_blendvps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2029    where
2030        Assembler<'a>: SseBlendvpsEmitter<A, B, C>,
2031    {
2032        <Self as SseBlendvpsEmitter<A, B, C>>::sse_blendvps(self, op0, op1, op2);
2033    }
2034    /// `SSE_DPPD`.
2035    ///
2036    /// Supported operand variants:
2037    ///
2038    /// ```text
2039    /// +---+---------------+
2040    /// | # | Operands      |
2041    /// +---+---------------+
2042    /// | 1 | Xmm, Mem, Imm |
2043    /// | 2 | Xmm, Xmm, Imm |
2044    /// +---+---------------+
2045    /// ```
2046    #[inline]
2047    pub fn sse_dppd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2048    where
2049        Assembler<'a>: SseDppdEmitter<A, B, C>,
2050    {
2051        <Self as SseDppdEmitter<A, B, C>>::sse_dppd(self, op0, op1, op2);
2052    }
2053    /// `SSE_DPPS`.
2054    ///
2055    /// Supported operand variants:
2056    ///
2057    /// ```text
2058    /// +---+---------------+
2059    /// | # | Operands      |
2060    /// +---+---------------+
2061    /// | 1 | Xmm, Mem, Imm |
2062    /// | 2 | Xmm, Xmm, Imm |
2063    /// +---+---------------+
2064    /// ```
2065    #[inline]
2066    pub fn sse_dpps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2067    where
2068        Assembler<'a>: SseDppsEmitter<A, B, C>,
2069    {
2070        <Self as SseDppsEmitter<A, B, C>>::sse_dpps(self, op0, op1, op2);
2071    }
2072    /// `SSE_EXTRACTPS`.
2073    ///
2074    /// Supported operand variants:
2075    ///
2076    /// ```text
2077    /// +---+---------------+
2078    /// | # | Operands      |
2079    /// +---+---------------+
2080    /// | 1 | Gpd, Xmm, Imm |
2081    /// | 2 | Mem, Xmm, Imm |
2082    /// +---+---------------+
2083    /// ```
2084    #[inline]
2085    pub fn sse_extractps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2086    where
2087        Assembler<'a>: SseExtractpsEmitter<A, B, C>,
2088    {
2089        <Self as SseExtractpsEmitter<A, B, C>>::sse_extractps(self, op0, op1, op2);
2090    }
2091    /// `SSE_INSERTPS`.
2092    ///
2093    /// Supported operand variants:
2094    ///
2095    /// ```text
2096    /// +---+---------------+
2097    /// | # | Operands      |
2098    /// +---+---------------+
2099    /// | 1 | Xmm, Mem, Imm |
2100    /// | 2 | Xmm, Xmm, Imm |
2101    /// +---+---------------+
2102    /// ```
2103    #[inline]
2104    pub fn sse_insertps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2105    where
2106        Assembler<'a>: SseInsertpsEmitter<A, B, C>,
2107    {
2108        <Self as SseInsertpsEmitter<A, B, C>>::sse_insertps(self, op0, op1, op2);
2109    }
2110    /// `SSE_MOVNTDQA`.
2111    ///
2112    /// Supported operand variants:
2113    ///
2114    /// ```text
2115    /// +---+----------+
2116    /// | # | Operands |
2117    /// +---+----------+
2118    /// | 1 | Xmm, Mem |
2119    /// +---+----------+
2120    /// ```
2121    #[inline]
2122    pub fn sse_movntdqa<A, B>(&mut self, op0: A, op1: B)
2123    where
2124        Assembler<'a>: SseMovntdqaEmitter<A, B>,
2125    {
2126        <Self as SseMovntdqaEmitter<A, B>>::sse_movntdqa(self, op0, op1);
2127    }
2128    /// `SSE_MPSADBW`.
2129    ///
2130    /// Supported operand variants:
2131    ///
2132    /// ```text
2133    /// +---+---------------+
2134    /// | # | Operands      |
2135    /// +---+---------------+
2136    /// | 1 | Xmm, Mem, Imm |
2137    /// | 2 | Xmm, Xmm, Imm |
2138    /// +---+---------------+
2139    /// ```
2140    #[inline]
2141    pub fn sse_mpsadbw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2142    where
2143        Assembler<'a>: SseMpsadbwEmitter<A, B, C>,
2144    {
2145        <Self as SseMpsadbwEmitter<A, B, C>>::sse_mpsadbw(self, op0, op1, op2);
2146    }
2147    /// `SSE_PACKUSDW`.
2148    ///
2149    /// Supported operand variants:
2150    ///
2151    /// ```text
2152    /// +---+----------+
2153    /// | # | Operands |
2154    /// +---+----------+
2155    /// | 1 | Xmm, Mem |
2156    /// | 2 | Xmm, Xmm |
2157    /// +---+----------+
2158    /// ```
2159    #[inline]
2160    pub fn sse_packusdw<A, B>(&mut self, op0: A, op1: B)
2161    where
2162        Assembler<'a>: SsePackusdwEmitter<A, B>,
2163    {
2164        <Self as SsePackusdwEmitter<A, B>>::sse_packusdw(self, op0, op1);
2165    }
2166    /// `SSE_PBLENDVB`.
2167    ///
2168    /// Supported operand variants:
2169    ///
2170    /// ```text
2171    /// +---+----------+
2172    /// | # | Operands |
2173    /// +---+----------+
2174    /// | 1 | Xmm, Mem |
2175    /// | 2 | Xmm, Xmm |
2176    /// +---+----------+
2177    /// ```
2178    #[inline]
2179    pub fn sse_pblendvb<A, B>(&mut self, op0: A, op1: B)
2180    where
2181        Assembler<'a>: SsePblendvbEmitter<A, B>,
2182    {
2183        <Self as SsePblendvbEmitter<A, B>>::sse_pblendvb(self, op0, op1);
2184    }
2185    /// `SSE_PBLENDW`.
2186    ///
2187    /// Supported operand variants:
2188    ///
2189    /// ```text
2190    /// +---+---------------+
2191    /// | # | Operands      |
2192    /// +---+---------------+
2193    /// | 1 | Xmm, Mem, Imm |
2194    /// | 2 | Xmm, Xmm, Imm |
2195    /// +---+---------------+
2196    /// ```
2197    #[inline]
2198    pub fn sse_pblendw<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2199    where
2200        Assembler<'a>: SsePblendwEmitter<A, B, C>,
2201    {
2202        <Self as SsePblendwEmitter<A, B, C>>::sse_pblendw(self, op0, op1, op2);
2203    }
2204    /// `SSE_PCMPEQQ`.
2205    ///
2206    /// Supported operand variants:
2207    ///
2208    /// ```text
2209    /// +---+----------+
2210    /// | # | Operands |
2211    /// +---+----------+
2212    /// | 1 | Xmm, Mem |
2213    /// | 2 | Xmm, Xmm |
2214    /// +---+----------+
2215    /// ```
2216    #[inline]
2217    pub fn sse_pcmpeqq<A, B>(&mut self, op0: A, op1: B)
2218    where
2219        Assembler<'a>: SsePcmpeqqEmitter<A, B>,
2220    {
2221        <Self as SsePcmpeqqEmitter<A, B>>::sse_pcmpeqq(self, op0, op1);
2222    }
2223    /// `SSE_PCMPGTQ`.
2224    ///
2225    /// Supported operand variants:
2226    ///
2227    /// ```text
2228    /// +---+----------+
2229    /// | # | Operands |
2230    /// +---+----------+
2231    /// | 1 | Xmm, Mem |
2232    /// | 2 | Xmm, Xmm |
2233    /// +---+----------+
2234    /// ```
2235    #[inline]
2236    pub fn sse_pcmpgtq<A, B>(&mut self, op0: A, op1: B)
2237    where
2238        Assembler<'a>: SsePcmpgtqEmitter<A, B>,
2239    {
2240        <Self as SsePcmpgtqEmitter<A, B>>::sse_pcmpgtq(self, op0, op1);
2241    }
2242    /// `SSE_PEXTRB`.
2243    ///
2244    /// Supported operand variants:
2245    ///
2246    /// ```text
2247    /// +---+---------------+
2248    /// | # | Operands      |
2249    /// +---+---------------+
2250    /// | 1 | Gpd, Xmm, Imm |
2251    /// | 2 | Mem, Xmm, Imm |
2252    /// +---+---------------+
2253    /// ```
2254    #[inline]
2255    pub fn sse_pextrb<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2256    where
2257        Assembler<'a>: SsePextrbEmitter<A, B, C>,
2258    {
2259        <Self as SsePextrbEmitter<A, B, C>>::sse_pextrb(self, op0, op1, op2);
2260    }
2261    /// `SSE_PEXTRD`.
2262    ///
2263    /// Supported operand variants:
2264    ///
2265    /// ```text
2266    /// +---+---------------+
2267    /// | # | Operands      |
2268    /// +---+---------------+
2269    /// | 1 | Gpd, Xmm, Imm |
2270    /// | 2 | Mem, Xmm, Imm |
2271    /// +---+---------------+
2272    /// ```
2273    #[inline]
2274    pub fn sse_pextrd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2275    where
2276        Assembler<'a>: SsePextrdEmitter<A, B, C>,
2277    {
2278        <Self as SsePextrdEmitter<A, B, C>>::sse_pextrd(self, op0, op1, op2);
2279    }
2280    /// `SSE_PEXTRQ`.
2281    ///
2282    /// Supported operand variants:
2283    ///
2284    /// ```text
2285    /// +---+---------------+
2286    /// | # | Operands      |
2287    /// +---+---------------+
2288    /// | 1 | Gpd, Xmm, Imm |
2289    /// | 2 | Mem, Xmm, Imm |
2290    /// +---+---------------+
2291    /// ```
2292    #[inline]
2293    pub fn sse_pextrq<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2294    where
2295        Assembler<'a>: SsePextrqEmitter<A, B, C>,
2296    {
2297        <Self as SsePextrqEmitter<A, B, C>>::sse_pextrq(self, op0, op1, op2);
2298    }
2299    /// `SSE_PHMINPOSUW`.
2300    ///
2301    /// Supported operand variants:
2302    ///
2303    /// ```text
2304    /// +---+----------+
2305    /// | # | Operands |
2306    /// +---+----------+
2307    /// | 1 | Xmm, Mem |
2308    /// | 2 | Xmm, Xmm |
2309    /// +---+----------+
2310    /// ```
2311    #[inline]
2312    pub fn sse_phminposuw<A, B>(&mut self, op0: A, op1: B)
2313    where
2314        Assembler<'a>: SsePhminposuwEmitter<A, B>,
2315    {
2316        <Self as SsePhminposuwEmitter<A, B>>::sse_phminposuw(self, op0, op1);
2317    }
2318    /// `SSE_PINSRB`.
2319    ///
2320    /// Supported operand variants:
2321    ///
2322    /// ```text
2323    /// +---+---------------+
2324    /// | # | Operands      |
2325    /// +---+---------------+
2326    /// | 1 | Xmm, Gpd, Imm |
2327    /// | 2 | Xmm, Mem, Imm |
2328    /// +---+---------------+
2329    /// ```
2330    #[inline]
2331    pub fn sse_pinsrb<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2332    where
2333        Assembler<'a>: SsePinsrbEmitter<A, B, C>,
2334    {
2335        <Self as SsePinsrbEmitter<A, B, C>>::sse_pinsrb(self, op0, op1, op2);
2336    }
2337    /// `SSE_PINSRD`.
2338    ///
2339    /// Supported operand variants:
2340    ///
2341    /// ```text
2342    /// +---+---------------+
2343    /// | # | Operands      |
2344    /// +---+---------------+
2345    /// | 1 | Xmm, Gpd, Imm |
2346    /// | 2 | Xmm, Mem, Imm |
2347    /// +---+---------------+
2348    /// ```
2349    #[inline]
2350    pub fn sse_pinsrd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2351    where
2352        Assembler<'a>: SsePinsrdEmitter<A, B, C>,
2353    {
2354        <Self as SsePinsrdEmitter<A, B, C>>::sse_pinsrd(self, op0, op1, op2);
2355    }
2356    /// `SSE_PINSRQ`.
2357    ///
2358    /// Supported operand variants:
2359    ///
2360    /// ```text
2361    /// +---+---------------+
2362    /// | # | Operands      |
2363    /// +---+---------------+
2364    /// | 1 | Xmm, Gpd, Imm |
2365    /// | 2 | Xmm, Mem, Imm |
2366    /// +---+---------------+
2367    /// ```
2368    #[inline]
2369    pub fn sse_pinsrq<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2370    where
2371        Assembler<'a>: SsePinsrqEmitter<A, B, C>,
2372    {
2373        <Self as SsePinsrqEmitter<A, B, C>>::sse_pinsrq(self, op0, op1, op2);
2374    }
2375    /// `SSE_PMAXSB`.
2376    ///
2377    /// Supported operand variants:
2378    ///
2379    /// ```text
2380    /// +---+----------+
2381    /// | # | Operands |
2382    /// +---+----------+
2383    /// | 1 | Xmm, Mem |
2384    /// | 2 | Xmm, Xmm |
2385    /// +---+----------+
2386    /// ```
2387    #[inline]
2388    pub fn sse_pmaxsb<A, B>(&mut self, op0: A, op1: B)
2389    where
2390        Assembler<'a>: SsePmaxsbEmitter<A, B>,
2391    {
2392        <Self as SsePmaxsbEmitter<A, B>>::sse_pmaxsb(self, op0, op1);
2393    }
2394    /// `SSE_PMAXSD`.
2395    ///
2396    /// Supported operand variants:
2397    ///
2398    /// ```text
2399    /// +---+----------+
2400    /// | # | Operands |
2401    /// +---+----------+
2402    /// | 1 | Xmm, Mem |
2403    /// | 2 | Xmm, Xmm |
2404    /// +---+----------+
2405    /// ```
2406    #[inline]
2407    pub fn sse_pmaxsd<A, B>(&mut self, op0: A, op1: B)
2408    where
2409        Assembler<'a>: SsePmaxsdEmitter<A, B>,
2410    {
2411        <Self as SsePmaxsdEmitter<A, B>>::sse_pmaxsd(self, op0, op1);
2412    }
2413    /// `SSE_PMAXUD`.
2414    ///
2415    /// Supported operand variants:
2416    ///
2417    /// ```text
2418    /// +---+----------+
2419    /// | # | Operands |
2420    /// +---+----------+
2421    /// | 1 | Xmm, Mem |
2422    /// | 2 | Xmm, Xmm |
2423    /// +---+----------+
2424    /// ```
2425    #[inline]
2426    pub fn sse_pmaxud<A, B>(&mut self, op0: A, op1: B)
2427    where
2428        Assembler<'a>: SsePmaxudEmitter<A, B>,
2429    {
2430        <Self as SsePmaxudEmitter<A, B>>::sse_pmaxud(self, op0, op1);
2431    }
2432    /// `SSE_PMAXUW`.
2433    ///
2434    /// Supported operand variants:
2435    ///
2436    /// ```text
2437    /// +---+----------+
2438    /// | # | Operands |
2439    /// +---+----------+
2440    /// | 1 | Xmm, Mem |
2441    /// | 2 | Xmm, Xmm |
2442    /// +---+----------+
2443    /// ```
2444    #[inline]
2445    pub fn sse_pmaxuw<A, B>(&mut self, op0: A, op1: B)
2446    where
2447        Assembler<'a>: SsePmaxuwEmitter<A, B>,
2448    {
2449        <Self as SsePmaxuwEmitter<A, B>>::sse_pmaxuw(self, op0, op1);
2450    }
2451    /// `SSE_PMINSB`.
2452    ///
2453    /// Supported operand variants:
2454    ///
2455    /// ```text
2456    /// +---+----------+
2457    /// | # | Operands |
2458    /// +---+----------+
2459    /// | 1 | Xmm, Mem |
2460    /// | 2 | Xmm, Xmm |
2461    /// +---+----------+
2462    /// ```
2463    #[inline]
2464    pub fn sse_pminsb<A, B>(&mut self, op0: A, op1: B)
2465    where
2466        Assembler<'a>: SsePminsbEmitter<A, B>,
2467    {
2468        <Self as SsePminsbEmitter<A, B>>::sse_pminsb(self, op0, op1);
2469    }
2470    /// `SSE_PMINSD`.
2471    ///
2472    /// Supported operand variants:
2473    ///
2474    /// ```text
2475    /// +---+----------+
2476    /// | # | Operands |
2477    /// +---+----------+
2478    /// | 1 | Xmm, Mem |
2479    /// | 2 | Xmm, Xmm |
2480    /// +---+----------+
2481    /// ```
2482    #[inline]
2483    pub fn sse_pminsd<A, B>(&mut self, op0: A, op1: B)
2484    where
2485        Assembler<'a>: SsePminsdEmitter<A, B>,
2486    {
2487        <Self as SsePminsdEmitter<A, B>>::sse_pminsd(self, op0, op1);
2488    }
2489    /// `SSE_PMINUD`.
2490    ///
2491    /// Supported operand variants:
2492    ///
2493    /// ```text
2494    /// +---+----------+
2495    /// | # | Operands |
2496    /// +---+----------+
2497    /// | 1 | Xmm, Mem |
2498    /// | 2 | Xmm, Xmm |
2499    /// +---+----------+
2500    /// ```
2501    #[inline]
2502    pub fn sse_pminud<A, B>(&mut self, op0: A, op1: B)
2503    where
2504        Assembler<'a>: SsePminudEmitter<A, B>,
2505    {
2506        <Self as SsePminudEmitter<A, B>>::sse_pminud(self, op0, op1);
2507    }
2508    /// `SSE_PMINUW`.
2509    ///
2510    /// Supported operand variants:
2511    ///
2512    /// ```text
2513    /// +---+----------+
2514    /// | # | Operands |
2515    /// +---+----------+
2516    /// | 1 | Xmm, Mem |
2517    /// | 2 | Xmm, Xmm |
2518    /// +---+----------+
2519    /// ```
2520    #[inline]
2521    pub fn sse_pminuw<A, B>(&mut self, op0: A, op1: B)
2522    where
2523        Assembler<'a>: SsePminuwEmitter<A, B>,
2524    {
2525        <Self as SsePminuwEmitter<A, B>>::sse_pminuw(self, op0, op1);
2526    }
2527    /// `SSE_PMOVSXBD`.
2528    ///
2529    /// Supported operand variants:
2530    ///
2531    /// ```text
2532    /// +---+----------+
2533    /// | # | Operands |
2534    /// +---+----------+
2535    /// | 1 | Xmm, Mem |
2536    /// | 2 | Xmm, Xmm |
2537    /// +---+----------+
2538    /// ```
2539    #[inline]
2540    pub fn sse_pmovsxbd<A, B>(&mut self, op0: A, op1: B)
2541    where
2542        Assembler<'a>: SsePmovsxbdEmitter<A, B>,
2543    {
2544        <Self as SsePmovsxbdEmitter<A, B>>::sse_pmovsxbd(self, op0, op1);
2545    }
2546    /// `SSE_PMOVSXBQ`.
2547    ///
2548    /// Supported operand variants:
2549    ///
2550    /// ```text
2551    /// +---+----------+
2552    /// | # | Operands |
2553    /// +---+----------+
2554    /// | 1 | Xmm, Mem |
2555    /// | 2 | Xmm, Xmm |
2556    /// +---+----------+
2557    /// ```
2558    #[inline]
2559    pub fn sse_pmovsxbq<A, B>(&mut self, op0: A, op1: B)
2560    where
2561        Assembler<'a>: SsePmovsxbqEmitter<A, B>,
2562    {
2563        <Self as SsePmovsxbqEmitter<A, B>>::sse_pmovsxbq(self, op0, op1);
2564    }
2565    /// `SSE_PMOVSXBW`.
2566    ///
2567    /// Supported operand variants:
2568    ///
2569    /// ```text
2570    /// +---+----------+
2571    /// | # | Operands |
2572    /// +---+----------+
2573    /// | 1 | Xmm, Mem |
2574    /// | 2 | Xmm, Xmm |
2575    /// +---+----------+
2576    /// ```
2577    #[inline]
2578    pub fn sse_pmovsxbw<A, B>(&mut self, op0: A, op1: B)
2579    where
2580        Assembler<'a>: SsePmovsxbwEmitter<A, B>,
2581    {
2582        <Self as SsePmovsxbwEmitter<A, B>>::sse_pmovsxbw(self, op0, op1);
2583    }
2584    /// `SSE_PMOVSXDQ`.
2585    ///
2586    /// Supported operand variants:
2587    ///
2588    /// ```text
2589    /// +---+----------+
2590    /// | # | Operands |
2591    /// +---+----------+
2592    /// | 1 | Xmm, Mem |
2593    /// | 2 | Xmm, Xmm |
2594    /// +---+----------+
2595    /// ```
2596    #[inline]
2597    pub fn sse_pmovsxdq<A, B>(&mut self, op0: A, op1: B)
2598    where
2599        Assembler<'a>: SsePmovsxdqEmitter<A, B>,
2600    {
2601        <Self as SsePmovsxdqEmitter<A, B>>::sse_pmovsxdq(self, op0, op1);
2602    }
2603    /// `SSE_PMOVSXWD`.
2604    ///
2605    /// Supported operand variants:
2606    ///
2607    /// ```text
2608    /// +---+----------+
2609    /// | # | Operands |
2610    /// +---+----------+
2611    /// | 1 | Xmm, Mem |
2612    /// | 2 | Xmm, Xmm |
2613    /// +---+----------+
2614    /// ```
2615    #[inline]
2616    pub fn sse_pmovsxwd<A, B>(&mut self, op0: A, op1: B)
2617    where
2618        Assembler<'a>: SsePmovsxwdEmitter<A, B>,
2619    {
2620        <Self as SsePmovsxwdEmitter<A, B>>::sse_pmovsxwd(self, op0, op1);
2621    }
2622    /// `SSE_PMOVSXWQ`.
2623    ///
2624    /// Supported operand variants:
2625    ///
2626    /// ```text
2627    /// +---+----------+
2628    /// | # | Operands |
2629    /// +---+----------+
2630    /// | 1 | Xmm, Mem |
2631    /// | 2 | Xmm, Xmm |
2632    /// +---+----------+
2633    /// ```
2634    #[inline]
2635    pub fn sse_pmovsxwq<A, B>(&mut self, op0: A, op1: B)
2636    where
2637        Assembler<'a>: SsePmovsxwqEmitter<A, B>,
2638    {
2639        <Self as SsePmovsxwqEmitter<A, B>>::sse_pmovsxwq(self, op0, op1);
2640    }
2641    /// `SSE_PMOVZXBD`.
2642    ///
2643    /// Supported operand variants:
2644    ///
2645    /// ```text
2646    /// +---+----------+
2647    /// | # | Operands |
2648    /// +---+----------+
2649    /// | 1 | Xmm, Mem |
2650    /// | 2 | Xmm, Xmm |
2651    /// +---+----------+
2652    /// ```
2653    #[inline]
2654    pub fn sse_pmovzxbd<A, B>(&mut self, op0: A, op1: B)
2655    where
2656        Assembler<'a>: SsePmovzxbdEmitter<A, B>,
2657    {
2658        <Self as SsePmovzxbdEmitter<A, B>>::sse_pmovzxbd(self, op0, op1);
2659    }
2660    /// `SSE_PMOVZXBQ`.
2661    ///
2662    /// Supported operand variants:
2663    ///
2664    /// ```text
2665    /// +---+----------+
2666    /// | # | Operands |
2667    /// +---+----------+
2668    /// | 1 | Xmm, Mem |
2669    /// | 2 | Xmm, Xmm |
2670    /// +---+----------+
2671    /// ```
2672    #[inline]
2673    pub fn sse_pmovzxbq<A, B>(&mut self, op0: A, op1: B)
2674    where
2675        Assembler<'a>: SsePmovzxbqEmitter<A, B>,
2676    {
2677        <Self as SsePmovzxbqEmitter<A, B>>::sse_pmovzxbq(self, op0, op1);
2678    }
2679    /// `SSE_PMOVZXBW`.
2680    ///
2681    /// Supported operand variants:
2682    ///
2683    /// ```text
2684    /// +---+----------+
2685    /// | # | Operands |
2686    /// +---+----------+
2687    /// | 1 | Xmm, Mem |
2688    /// | 2 | Xmm, Xmm |
2689    /// +---+----------+
2690    /// ```
2691    #[inline]
2692    pub fn sse_pmovzxbw<A, B>(&mut self, op0: A, op1: B)
2693    where
2694        Assembler<'a>: SsePmovzxbwEmitter<A, B>,
2695    {
2696        <Self as SsePmovzxbwEmitter<A, B>>::sse_pmovzxbw(self, op0, op1);
2697    }
2698    /// `SSE_PMOVZXDQ`.
2699    ///
2700    /// Supported operand variants:
2701    ///
2702    /// ```text
2703    /// +---+----------+
2704    /// | # | Operands |
2705    /// +---+----------+
2706    /// | 1 | Xmm, Mem |
2707    /// | 2 | Xmm, Xmm |
2708    /// +---+----------+
2709    /// ```
2710    #[inline]
2711    pub fn sse_pmovzxdq<A, B>(&mut self, op0: A, op1: B)
2712    where
2713        Assembler<'a>: SsePmovzxdqEmitter<A, B>,
2714    {
2715        <Self as SsePmovzxdqEmitter<A, B>>::sse_pmovzxdq(self, op0, op1);
2716    }
2717    /// `SSE_PMOVZXWD`.
2718    ///
2719    /// Supported operand variants:
2720    ///
2721    /// ```text
2722    /// +---+----------+
2723    /// | # | Operands |
2724    /// +---+----------+
2725    /// | 1 | Xmm, Mem |
2726    /// | 2 | Xmm, Xmm |
2727    /// +---+----------+
2728    /// ```
2729    #[inline]
2730    pub fn sse_pmovzxwd<A, B>(&mut self, op0: A, op1: B)
2731    where
2732        Assembler<'a>: SsePmovzxwdEmitter<A, B>,
2733    {
2734        <Self as SsePmovzxwdEmitter<A, B>>::sse_pmovzxwd(self, op0, op1);
2735    }
2736    /// `SSE_PMOVZXWQ`.
2737    ///
2738    /// Supported operand variants:
2739    ///
2740    /// ```text
2741    /// +---+----------+
2742    /// | # | Operands |
2743    /// +---+----------+
2744    /// | 1 | Xmm, Mem |
2745    /// | 2 | Xmm, Xmm |
2746    /// +---+----------+
2747    /// ```
2748    #[inline]
2749    pub fn sse_pmovzxwq<A, B>(&mut self, op0: A, op1: B)
2750    where
2751        Assembler<'a>: SsePmovzxwqEmitter<A, B>,
2752    {
2753        <Self as SsePmovzxwqEmitter<A, B>>::sse_pmovzxwq(self, op0, op1);
2754    }
2755    /// `SSE_PMULDQ`.
2756    ///
2757    /// Supported operand variants:
2758    ///
2759    /// ```text
2760    /// +---+----------+
2761    /// | # | Operands |
2762    /// +---+----------+
2763    /// | 1 | Xmm, Mem |
2764    /// | 2 | Xmm, Xmm |
2765    /// +---+----------+
2766    /// ```
2767    #[inline]
2768    pub fn sse_pmuldq<A, B>(&mut self, op0: A, op1: B)
2769    where
2770        Assembler<'a>: SsePmuldqEmitter<A, B>,
2771    {
2772        <Self as SsePmuldqEmitter<A, B>>::sse_pmuldq(self, op0, op1);
2773    }
2774    /// `SSE_PMULLD`.
2775    ///
2776    /// Supported operand variants:
2777    ///
2778    /// ```text
2779    /// +---+----------+
2780    /// | # | Operands |
2781    /// +---+----------+
2782    /// | 1 | Xmm, Mem |
2783    /// | 2 | Xmm, Xmm |
2784    /// +---+----------+
2785    /// ```
2786    #[inline]
2787    pub fn sse_pmulld<A, B>(&mut self, op0: A, op1: B)
2788    where
2789        Assembler<'a>: SsePmulldEmitter<A, B>,
2790    {
2791        <Self as SsePmulldEmitter<A, B>>::sse_pmulld(self, op0, op1);
2792    }
2793    /// `SSE_PTEST`.
2794    ///
2795    /// Supported operand variants:
2796    ///
2797    /// ```text
2798    /// +---+----------+
2799    /// | # | Operands |
2800    /// +---+----------+
2801    /// | 1 | Xmm, Mem |
2802    /// | 2 | Xmm, Xmm |
2803    /// +---+----------+
2804    /// ```
2805    #[inline]
2806    pub fn sse_ptest<A, B>(&mut self, op0: A, op1: B)
2807    where
2808        Assembler<'a>: SsePtestEmitter<A, B>,
2809    {
2810        <Self as SsePtestEmitter<A, B>>::sse_ptest(self, op0, op1);
2811    }
2812    /// `SSE_ROUNDPD`.
2813    ///
2814    /// Supported operand variants:
2815    ///
2816    /// ```text
2817    /// +---+---------------+
2818    /// | # | Operands      |
2819    /// +---+---------------+
2820    /// | 1 | Xmm, Mem, Imm |
2821    /// | 2 | Xmm, Xmm, Imm |
2822    /// +---+---------------+
2823    /// ```
2824    #[inline]
2825    pub fn sse_roundpd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2826    where
2827        Assembler<'a>: SseRoundpdEmitter<A, B, C>,
2828    {
2829        <Self as SseRoundpdEmitter<A, B, C>>::sse_roundpd(self, op0, op1, op2);
2830    }
2831    /// `SSE_ROUNDPS`.
2832    ///
2833    /// Supported operand variants:
2834    ///
2835    /// ```text
2836    /// +---+---------------+
2837    /// | # | Operands      |
2838    /// +---+---------------+
2839    /// | 1 | Xmm, Mem, Imm |
2840    /// | 2 | Xmm, Xmm, Imm |
2841    /// +---+---------------+
2842    /// ```
2843    #[inline]
2844    pub fn sse_roundps<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2845    where
2846        Assembler<'a>: SseRoundpsEmitter<A, B, C>,
2847    {
2848        <Self as SseRoundpsEmitter<A, B, C>>::sse_roundps(self, op0, op1, op2);
2849    }
2850    /// `SSE_ROUNDSD`.
2851    ///
2852    /// Supported operand variants:
2853    ///
2854    /// ```text
2855    /// +---+---------------+
2856    /// | # | Operands      |
2857    /// +---+---------------+
2858    /// | 1 | Xmm, Mem, Imm |
2859    /// | 2 | Xmm, Xmm, Imm |
2860    /// +---+---------------+
2861    /// ```
2862    #[inline]
2863    pub fn sse_roundsd<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2864    where
2865        Assembler<'a>: SseRoundsdEmitter<A, B, C>,
2866    {
2867        <Self as SseRoundsdEmitter<A, B, C>>::sse_roundsd(self, op0, op1, op2);
2868    }
2869    /// `SSE_ROUNDSS`.
2870    ///
2871    /// Supported operand variants:
2872    ///
2873    /// ```text
2874    /// +---+---------------+
2875    /// | # | Operands      |
2876    /// +---+---------------+
2877    /// | 1 | Xmm, Mem, Imm |
2878    /// | 2 | Xmm, Xmm, Imm |
2879    /// +---+---------------+
2880    /// ```
2881    #[inline]
2882    pub fn sse_roundss<A, B, C>(&mut self, op0: A, op1: B, op2: C)
2883    where
2884        Assembler<'a>: SseRoundssEmitter<A, B, C>,
2885    {
2886        <Self as SseRoundssEmitter<A, B, C>>::sse_roundss(self, op0, op1, op2);
2887    }
2888}
asmkit/x86/features/SSE41.rs

asmkit/x86/features/
SSE41.rs
