asmkit/x86/features/
AESKLE.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/// `AESDEC128KL`.
11///
12/// Supported operand variants:
13///
14/// ```text
15/// +---+----------+
16/// | # | Operands |
17/// +---+----------+
18/// | 1 | Xmm, Mem |
19/// +---+----------+
20/// ```
21pub trait Aesdec128klEmitter<A, B> {
22    fn aesdec128kl(&mut self, op0: A, op1: B);
23}
24
25impl<'a> Aesdec128klEmitter<Xmm, Mem> for Assembler<'a> {
26    fn aesdec128kl(&mut self, op0: Xmm, op1: Mem) {
27        self.emit(
28            AESDEC128KLRM,
29            op0.as_operand(),
30            op1.as_operand(),
31            &NOREG,
32            &NOREG,
33        );
34    }
35}
36
37/// `AESDEC256KL`.
38///
39/// Supported operand variants:
40///
41/// ```text
42/// +---+----------+
43/// | # | Operands |
44/// +---+----------+
45/// | 1 | Xmm, Mem |
46/// +---+----------+
47/// ```
48pub trait Aesdec256klEmitter<A, B> {
49    fn aesdec256kl(&mut self, op0: A, op1: B);
50}
51
52impl<'a> Aesdec256klEmitter<Xmm, Mem> for Assembler<'a> {
53    fn aesdec256kl(&mut self, op0: Xmm, op1: Mem) {
54        self.emit(
55            AESDEC256KLRM,
56            op0.as_operand(),
57            op1.as_operand(),
58            &NOREG,
59            &NOREG,
60        );
61    }
62}
63
64/// `AESDECWIDE128KL`.
65///
66/// Supported operand variants:
67///
68/// ```text
69/// +---+----------+
70/// | # | Operands |
71/// +---+----------+
72/// | 1 | Mem      |
73/// +---+----------+
74/// ```
75pub trait Aesdecwide128klEmitter<A> {
76    fn aesdecwide128kl(&mut self, op0: A);
77}
78
79impl<'a> Aesdecwide128klEmitter<Mem> for Assembler<'a> {
80    fn aesdecwide128kl(&mut self, op0: Mem) {
81        self.emit(AESDECWIDE128KLM, op0.as_operand(), &NOREG, &NOREG, &NOREG);
82    }
83}
84
85/// `AESDECWIDE256KL`.
86///
87/// Supported operand variants:
88///
89/// ```text
90/// +---+----------+
91/// | # | Operands |
92/// +---+----------+
93/// | 1 | Mem      |
94/// +---+----------+
95/// ```
96pub trait Aesdecwide256klEmitter<A> {
97    fn aesdecwide256kl(&mut self, op0: A);
98}
99
100impl<'a> Aesdecwide256klEmitter<Mem> for Assembler<'a> {
101    fn aesdecwide256kl(&mut self, op0: Mem) {
102        self.emit(AESDECWIDE256KLM, op0.as_operand(), &NOREG, &NOREG, &NOREG);
103    }
104}
105
106/// `AESENC128KL`.
107///
108/// Supported operand variants:
109///
110/// ```text
111/// +---+----------+
112/// | # | Operands |
113/// +---+----------+
114/// | 1 | Xmm, Mem |
115/// +---+----------+
116/// ```
117pub trait Aesenc128klEmitter<A, B> {
118    fn aesenc128kl(&mut self, op0: A, op1: B);
119}
120
121impl<'a> Aesenc128klEmitter<Xmm, Mem> for Assembler<'a> {
122    fn aesenc128kl(&mut self, op0: Xmm, op1: Mem) {
123        self.emit(
124            AESENC128KLRM,
125            op0.as_operand(),
126            op1.as_operand(),
127            &NOREG,
128            &NOREG,
129        );
130    }
131}
132
133/// `AESENC256KL`.
134///
135/// Supported operand variants:
136///
137/// ```text
138/// +---+----------+
139/// | # | Operands |
140/// +---+----------+
141/// | 1 | Xmm, Mem |
142/// +---+----------+
143/// ```
144pub trait Aesenc256klEmitter<A, B> {
145    fn aesenc256kl(&mut self, op0: A, op1: B);
146}
147
148impl<'a> Aesenc256klEmitter<Xmm, Mem> for Assembler<'a> {
149    fn aesenc256kl(&mut self, op0: Xmm, op1: Mem) {
150        self.emit(
151            AESENC256KLRM,
152            op0.as_operand(),
153            op1.as_operand(),
154            &NOREG,
155            &NOREG,
156        );
157    }
158}
159
160/// `AESENCWIDE128KL`.
161///
162/// Supported operand variants:
163///
164/// ```text
165/// +---+----------+
166/// | # | Operands |
167/// +---+----------+
168/// | 1 | Mem      |
169/// +---+----------+
170/// ```
171pub trait Aesencwide128klEmitter<A> {
172    fn aesencwide128kl(&mut self, op0: A);
173}
174
175impl<'a> Aesencwide128klEmitter<Mem> for Assembler<'a> {
176    fn aesencwide128kl(&mut self, op0: Mem) {
177        self.emit(AESENCWIDE128KLM, op0.as_operand(), &NOREG, &NOREG, &NOREG);
178    }
179}
180
181/// `AESENCWIDE256KL`.
182///
183/// Supported operand variants:
184///
185/// ```text
186/// +---+----------+
187/// | # | Operands |
188/// +---+----------+
189/// | 1 | Mem      |
190/// +---+----------+
191/// ```
192pub trait Aesencwide256klEmitter<A> {
193    fn aesencwide256kl(&mut self, op0: A);
194}
195
196impl<'a> Aesencwide256klEmitter<Mem> for Assembler<'a> {
197    fn aesencwide256kl(&mut self, op0: Mem) {
198        self.emit(AESENCWIDE256KLM, op0.as_operand(), &NOREG, &NOREG, &NOREG);
199    }
200}
201
202/// `ENCODEKEY128`.
203///
204/// Supported operand variants:
205///
206/// ```text
207/// +---+----------+
208/// | # | Operands |
209/// +---+----------+
210/// | 1 | Gpd, Gpd |
211/// +---+----------+
212/// ```
213pub trait Encodekey128Emitter<A, B> {
214    fn encodekey128(&mut self, op0: A, op1: B);
215}
216
217impl<'a> Encodekey128Emitter<Gpd, Gpd> for Assembler<'a> {
218    fn encodekey128(&mut self, op0: Gpd, op1: Gpd) {
219        self.emit(
220            ENCODEKEY128RR,
221            op0.as_operand(),
222            op1.as_operand(),
223            &NOREG,
224            &NOREG,
225        );
226    }
227}
228
229/// `ENCODEKEY256`.
230///
231/// Supported operand variants:
232///
233/// ```text
234/// +---+----------+
235/// | # | Operands |
236/// +---+----------+
237/// | 1 | Gpd, Gpd |
238/// +---+----------+
239/// ```
240pub trait Encodekey256Emitter<A, B> {
241    fn encodekey256(&mut self, op0: A, op1: B);
242}
243
244impl<'a> Encodekey256Emitter<Gpd, Gpd> for Assembler<'a> {
245    fn encodekey256(&mut self, op0: Gpd, op1: Gpd) {
246        self.emit(
247            ENCODEKEY256RR,
248            op0.as_operand(),
249            op1.as_operand(),
250            &NOREG,
251            &NOREG,
252        );
253    }
254}
255
256/// `LOADIWKEY`.
257///
258/// Supported operand variants:
259///
260/// ```text
261/// +---+----------+
262/// | # | Operands |
263/// +---+----------+
264/// | 1 | Xmm, Xmm |
265/// +---+----------+
266/// ```
267pub trait LoadiwkeyEmitter<A, B> {
268    fn loadiwkey(&mut self, op0: A, op1: B);
269}
270
271impl<'a> LoadiwkeyEmitter<Xmm, Xmm> for Assembler<'a> {
272    fn loadiwkey(&mut self, op0: Xmm, op1: Xmm) {
273        self.emit(
274            LOADIWKEYRR,
275            op0.as_operand(),
276            op1.as_operand(),
277            &NOREG,
278            &NOREG,
279        );
280    }
281}
282
283impl<'a> Assembler<'a> {
284    /// `AESDEC128KL`.
285    ///
286    /// Supported operand variants:
287    ///
288    /// ```text
289    /// +---+----------+
290    /// | # | Operands |
291    /// +---+----------+
292    /// | 1 | Xmm, Mem |
293    /// +---+----------+
294    /// ```
295    #[inline]
296    pub fn aesdec128kl<A, B>(&mut self, op0: A, op1: B)
297    where
298        Assembler<'a>: Aesdec128klEmitter<A, B>,
299    {
300        <Self as Aesdec128klEmitter<A, B>>::aesdec128kl(self, op0, op1);
301    }
302    /// `AESDEC256KL`.
303    ///
304    /// Supported operand variants:
305    ///
306    /// ```text
307    /// +---+----------+
308    /// | # | Operands |
309    /// +---+----------+
310    /// | 1 | Xmm, Mem |
311    /// +---+----------+
312    /// ```
313    #[inline]
314    pub fn aesdec256kl<A, B>(&mut self, op0: A, op1: B)
315    where
316        Assembler<'a>: Aesdec256klEmitter<A, B>,
317    {
318        <Self as Aesdec256klEmitter<A, B>>::aesdec256kl(self, op0, op1);
319    }
320    /// `AESDECWIDE128KL`.
321    ///
322    /// Supported operand variants:
323    ///
324    /// ```text
325    /// +---+----------+
326    /// | # | Operands |
327    /// +---+----------+
328    /// | 1 | Mem      |
329    /// +---+----------+
330    /// ```
331    #[inline]
332    pub fn aesdecwide128kl<A>(&mut self, op0: A)
333    where
334        Assembler<'a>: Aesdecwide128klEmitter<A>,
335    {
336        <Self as Aesdecwide128klEmitter<A>>::aesdecwide128kl(self, op0);
337    }
338    /// `AESDECWIDE256KL`.
339    ///
340    /// Supported operand variants:
341    ///
342    /// ```text
343    /// +---+----------+
344    /// | # | Operands |
345    /// +---+----------+
346    /// | 1 | Mem      |
347    /// +---+----------+
348    /// ```
349    #[inline]
350    pub fn aesdecwide256kl<A>(&mut self, op0: A)
351    where
352        Assembler<'a>: Aesdecwide256klEmitter<A>,
353    {
354        <Self as Aesdecwide256klEmitter<A>>::aesdecwide256kl(self, op0);
355    }
356    /// `AESENC128KL`.
357    ///
358    /// Supported operand variants:
359    ///
360    /// ```text
361    /// +---+----------+
362    /// | # | Operands |
363    /// +---+----------+
364    /// | 1 | Xmm, Mem |
365    /// +---+----------+
366    /// ```
367    #[inline]
368    pub fn aesenc128kl<A, B>(&mut self, op0: A, op1: B)
369    where
370        Assembler<'a>: Aesenc128klEmitter<A, B>,
371    {
372        <Self as Aesenc128klEmitter<A, B>>::aesenc128kl(self, op0, op1);
373    }
374    /// `AESENC256KL`.
375    ///
376    /// Supported operand variants:
377    ///
378    /// ```text
379    /// +---+----------+
380    /// | # | Operands |
381    /// +---+----------+
382    /// | 1 | Xmm, Mem |
383    /// +---+----------+
384    /// ```
385    #[inline]
386    pub fn aesenc256kl<A, B>(&mut self, op0: A, op1: B)
387    where
388        Assembler<'a>: Aesenc256klEmitter<A, B>,
389    {
390        <Self as Aesenc256klEmitter<A, B>>::aesenc256kl(self, op0, op1);
391    }
392    /// `AESENCWIDE128KL`.
393    ///
394    /// Supported operand variants:
395    ///
396    /// ```text
397    /// +---+----------+
398    /// | # | Operands |
399    /// +---+----------+
400    /// | 1 | Mem      |
401    /// +---+----------+
402    /// ```
403    #[inline]
404    pub fn aesencwide128kl<A>(&mut self, op0: A)
405    where
406        Assembler<'a>: Aesencwide128klEmitter<A>,
407    {
408        <Self as Aesencwide128klEmitter<A>>::aesencwide128kl(self, op0);
409    }
410    /// `AESENCWIDE256KL`.
411    ///
412    /// Supported operand variants:
413    ///
414    /// ```text
415    /// +---+----------+
416    /// | # | Operands |
417    /// +---+----------+
418    /// | 1 | Mem      |
419    /// +---+----------+
420    /// ```
421    #[inline]
422    pub fn aesencwide256kl<A>(&mut self, op0: A)
423    where
424        Assembler<'a>: Aesencwide256klEmitter<A>,
425    {
426        <Self as Aesencwide256klEmitter<A>>::aesencwide256kl(self, op0);
427    }
428    /// `ENCODEKEY128`.
429    ///
430    /// Supported operand variants:
431    ///
432    /// ```text
433    /// +---+----------+
434    /// | # | Operands |
435    /// +---+----------+
436    /// | 1 | Gpd, Gpd |
437    /// +---+----------+
438    /// ```
439    #[inline]
440    pub fn encodekey128<A, B>(&mut self, op0: A, op1: B)
441    where
442        Assembler<'a>: Encodekey128Emitter<A, B>,
443    {
444        <Self as Encodekey128Emitter<A, B>>::encodekey128(self, op0, op1);
445    }
446    /// `ENCODEKEY256`.
447    ///
448    /// Supported operand variants:
449    ///
450    /// ```text
451    /// +---+----------+
452    /// | # | Operands |
453    /// +---+----------+
454    /// | 1 | Gpd, Gpd |
455    /// +---+----------+
456    /// ```
457    #[inline]
458    pub fn encodekey256<A, B>(&mut self, op0: A, op1: B)
459    where
460        Assembler<'a>: Encodekey256Emitter<A, B>,
461    {
462        <Self as Encodekey256Emitter<A, B>>::encodekey256(self, op0, op1);
463    }
464    /// `LOADIWKEY`.
465    ///
466    /// Supported operand variants:
467    ///
468    /// ```text
469    /// +---+----------+
470    /// | # | Operands |
471    /// +---+----------+
472    /// | 1 | Xmm, Xmm |
473    /// +---+----------+
474    /// ```
475    #[inline]
476    pub fn loadiwkey<A, B>(&mut self, op0: A, op1: B)
477    where
478        Assembler<'a>: LoadiwkeyEmitter<A, B>,
479    {
480        <Self as LoadiwkeyEmitter<A, B>>::loadiwkey(self, op0, op1);
481    }
482}
asmkit/x86/features/AESKLE.rs

asmkit/x86/features/
AESKLE.rs
