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

asmkit/x86/features/
387.rs
