ptx_parser/unparser/instruction/
cvt.rs

1//! Original PTX specification:
2//!
3//! cvt{.irnd}{.ftz}{.sat}.dtype.atype         d, a;  // integer rounding
4//! cvt{.frnd}{.ftz}{.sat}.dtype.atype         d, a;  // fp rounding
5//! cvt.frnd2{.relu}{.satfinite}.f16.f32       d, a;
6//! cvt.frnd2{.relu}{.satfinite}.f16x2.f32     d, a, b;
7//! cvt.rs{.relu}{.satfinite}.f16x2.f32        d, a, b, rbits;
8//! cvt.frnd2{.relu}{.satfinite}.bf16.f32      d, a;
9//! cvt.frnd2{.relu}{.satfinite}.bf16x2.f32    d, a, b;
10//! cvt.rs{.relu}{.satfinite}.bf16x2.f32       d, a, b, rbits;
11//! cvt.rna{.satfinite}.tf32.f32               d, a;
12//! cvt.frnd2{.satfinite}{.relu}.tf32.f32      d, a;
13//! cvt.rn.satfinite{.relu}.f8x2type.f32       d, a, b;
14//! cvt.rn.satfinite{.relu}.f8x2type.f16x2     d, a;
15//! cvt.rn{.relu}.f16x2.f8x2type              d, a;
16//! cvt.rs{.relu}.satfinite.f8x4type.f32       d, {a, b, e, f}, rbits;
17//! cvt.rn.satfinite{.relu}.f4x2type.f32       d, a, b;
18//! cvt.rn{.relu}.f16x2.f4x2type               d, a;
19//! cvt.rs{.relu}.satfinite.f4x4type.f32       d, {a, b, e, f}, rbits;
20//! cvt.rn.satfinite{.relu}.f6x2type.f32       d, a, b;
21//! cvt.rn{.relu}.f16x2.f6x2type               d, a;
22//! cvt.rs{.relu}.satfinite.f6x4type.f32       d, {a, b, e, f}, rbits;
23//! cvt.frnd3{.satfinite}.ue8m0x2.f32          d, a, b;
24//! cvt.frnd3{.satfinite}.ue8m0x2.bf16x2       d, a;
25//! cvt.rn.bf16x2.ue8m0x2                      d, a;
26//! .irnd   = { .rni, .rzi, .rmi, .rpi };
27//! .frnd   = { .rn,  .rz,  .rm,  .rp  };
28//! .frnd2  = { .rn,  .rz };
29//! .frnd3  = { .rz,  .rp };
30//! .dtype = .atype = { .u8,   .u16, .u32, .u64,
31//! .s8,   .s16, .s32, .s64,
32//! .bf16, .f16, .f32, .f64 };
33//! .f8x2type = { .e4m3x2, .e5m2x2 };
34//! .f4x2type = { .e2m1x2 };
35//! .f6x2type = { .e2m3x2, .e3m2x2 };
36//! .f4x4type = { .e2m1x4 };
37//! .f8x4type = { .e4m3x4, .e5m2x4 };
38//! .f6x4type = { .e2m3x4, .e3m2x4 };
39
40#![allow(unused)]
41
42use crate::lexer::PtxToken;
43use crate::unparser::{PtxUnparser, common::*};
44
45pub mod section_0 {
46    use super::*;
47    use crate::r#type::instruction::cvt::section_0::*;
48
49    impl PtxUnparser for CvtIrndFtzSatDtypeAtype {
50        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
51            push_opcode(tokens, "cvt");
52            if let Some(irnd_0) = self.irnd.as_ref() {
53                match irnd_0 {
54                    Irnd::Rni => {
55                        push_directive(tokens, "rni");
56                    }
57                    Irnd::Rzi => {
58                        push_directive(tokens, "rzi");
59                    }
60                    Irnd::Rmi => {
61                        push_directive(tokens, "rmi");
62                    }
63                    Irnd::Rpi => {
64                        push_directive(tokens, "rpi");
65                    }
66                }
67            }
68            if self.ftz {
69                push_directive(tokens, "ftz");
70            }
71            if self.sat {
72                push_directive(tokens, "sat");
73            }
74            match &self.dtype {
75                Dtype::Bf16 => {
76                    push_directive(tokens, "bf16");
77                }
78                Dtype::U16 => {
79                    push_directive(tokens, "u16");
80                }
81                Dtype::U32 => {
82                    push_directive(tokens, "u32");
83                }
84                Dtype::U64 => {
85                    push_directive(tokens, "u64");
86                }
87                Dtype::S16 => {
88                    push_directive(tokens, "s16");
89                }
90                Dtype::S32 => {
91                    push_directive(tokens, "s32");
92                }
93                Dtype::S64 => {
94                    push_directive(tokens, "s64");
95                }
96                Dtype::F16 => {
97                    push_directive(tokens, "f16");
98                }
99                Dtype::F32 => {
100                    push_directive(tokens, "f32");
101                }
102                Dtype::F64 => {
103                    push_directive(tokens, "f64");
104                }
105                Dtype::U8 => {
106                    push_directive(tokens, "u8");
107                }
108                Dtype::S8 => {
109                    push_directive(tokens, "s8");
110                }
111            }
112            match &self.atype {
113                Atype::Bf16 => {
114                    push_directive(tokens, "bf16");
115                }
116                Atype::U16 => {
117                    push_directive(tokens, "u16");
118                }
119                Atype::U32 => {
120                    push_directive(tokens, "u32");
121                }
122                Atype::U64 => {
123                    push_directive(tokens, "u64");
124                }
125                Atype::S16 => {
126                    push_directive(tokens, "s16");
127                }
128                Atype::S32 => {
129                    push_directive(tokens, "s32");
130                }
131                Atype::S64 => {
132                    push_directive(tokens, "s64");
133                }
134                Atype::F16 => {
135                    push_directive(tokens, "f16");
136                }
137                Atype::F32 => {
138                    push_directive(tokens, "f32");
139                }
140                Atype::F64 => {
141                    push_directive(tokens, "f64");
142                }
143                Atype::U8 => {
144                    push_directive(tokens, "u8");
145                }
146                Atype::S8 => {
147                    push_directive(tokens, "s8");
148                }
149            }
150            self.d.unparse_tokens(tokens);
151            tokens.push(PtxToken::Comma);
152            self.a.unparse_tokens(tokens);
153            tokens.push(PtxToken::Semicolon);
154        }
155    }
156
157    impl PtxUnparser for CvtFrndFtzSatDtypeAtype {
158        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
159            push_opcode(tokens, "cvt");
160            if let Some(frnd_1) = self.frnd.as_ref() {
161                match frnd_1 {
162                    Frnd::Rn => {
163                        push_directive(tokens, "rn");
164                    }
165                    Frnd::Rz => {
166                        push_directive(tokens, "rz");
167                    }
168                    Frnd::Rm => {
169                        push_directive(tokens, "rm");
170                    }
171                    Frnd::Rp => {
172                        push_directive(tokens, "rp");
173                    }
174                }
175            }
176            if self.ftz {
177                push_directive(tokens, "ftz");
178            }
179            if self.sat {
180                push_directive(tokens, "sat");
181            }
182            match &self.dtype {
183                Dtype::Bf16 => {
184                    push_directive(tokens, "bf16");
185                }
186                Dtype::U16 => {
187                    push_directive(tokens, "u16");
188                }
189                Dtype::U32 => {
190                    push_directive(tokens, "u32");
191                }
192                Dtype::U64 => {
193                    push_directive(tokens, "u64");
194                }
195                Dtype::S16 => {
196                    push_directive(tokens, "s16");
197                }
198                Dtype::S32 => {
199                    push_directive(tokens, "s32");
200                }
201                Dtype::S64 => {
202                    push_directive(tokens, "s64");
203                }
204                Dtype::F16 => {
205                    push_directive(tokens, "f16");
206                }
207                Dtype::F32 => {
208                    push_directive(tokens, "f32");
209                }
210                Dtype::F64 => {
211                    push_directive(tokens, "f64");
212                }
213                Dtype::U8 => {
214                    push_directive(tokens, "u8");
215                }
216                Dtype::S8 => {
217                    push_directive(tokens, "s8");
218                }
219            }
220            match &self.atype {
221                Atype::Bf16 => {
222                    push_directive(tokens, "bf16");
223                }
224                Atype::U16 => {
225                    push_directive(tokens, "u16");
226                }
227                Atype::U32 => {
228                    push_directive(tokens, "u32");
229                }
230                Atype::U64 => {
231                    push_directive(tokens, "u64");
232                }
233                Atype::S16 => {
234                    push_directive(tokens, "s16");
235                }
236                Atype::S32 => {
237                    push_directive(tokens, "s32");
238                }
239                Atype::S64 => {
240                    push_directive(tokens, "s64");
241                }
242                Atype::F16 => {
243                    push_directive(tokens, "f16");
244                }
245                Atype::F32 => {
246                    push_directive(tokens, "f32");
247                }
248                Atype::F64 => {
249                    push_directive(tokens, "f64");
250                }
251                Atype::U8 => {
252                    push_directive(tokens, "u8");
253                }
254                Atype::S8 => {
255                    push_directive(tokens, "s8");
256                }
257            }
258            self.d.unparse_tokens(tokens);
259            tokens.push(PtxToken::Comma);
260            self.a.unparse_tokens(tokens);
261            tokens.push(PtxToken::Semicolon);
262        }
263    }
264
265    impl PtxUnparser for CvtFrnd2ReluSatfiniteF16F32 {
266        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
267            push_opcode(tokens, "cvt");
268            match &self.frnd2 {
269                Frnd2::Rn => {
270                    push_directive(tokens, "rn");
271                }
272                Frnd2::Rz => {
273                    push_directive(tokens, "rz");
274                }
275            }
276            if self.relu {
277                push_directive(tokens, "relu");
278            }
279            if self.satfinite {
280                push_directive(tokens, "satfinite");
281            }
282            push_directive(tokens, "f16");
283            push_directive(tokens, "f32");
284            self.d.unparse_tokens(tokens);
285            tokens.push(PtxToken::Comma);
286            self.a.unparse_tokens(tokens);
287            tokens.push(PtxToken::Semicolon);
288        }
289    }
290
291    impl PtxUnparser for CvtFrnd2ReluSatfiniteF16x2F32 {
292        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
293            push_opcode(tokens, "cvt");
294            match &self.frnd2 {
295                Frnd2::Rn => {
296                    push_directive(tokens, "rn");
297                }
298                Frnd2::Rz => {
299                    push_directive(tokens, "rz");
300                }
301            }
302            if self.relu {
303                push_directive(tokens, "relu");
304            }
305            if self.satfinite {
306                push_directive(tokens, "satfinite");
307            }
308            push_directive(tokens, "f16x2");
309            push_directive(tokens, "f32");
310            self.d.unparse_tokens(tokens);
311            tokens.push(PtxToken::Comma);
312            self.a.unparse_tokens(tokens);
313            tokens.push(PtxToken::Comma);
314            self.b.unparse_tokens(tokens);
315            tokens.push(PtxToken::Semicolon);
316        }
317    }
318
319    impl PtxUnparser for CvtRsReluSatfiniteF16x2F32 {
320        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
321            push_opcode(tokens, "cvt");
322            push_directive(tokens, "rs");
323            if self.relu {
324                push_directive(tokens, "relu");
325            }
326            if self.satfinite {
327                push_directive(tokens, "satfinite");
328            }
329            push_directive(tokens, "f16x2");
330            push_directive(tokens, "f32");
331            self.d.unparse_tokens(tokens);
332            tokens.push(PtxToken::Comma);
333            self.a.unparse_tokens(tokens);
334            tokens.push(PtxToken::Comma);
335            self.b.unparse_tokens(tokens);
336            tokens.push(PtxToken::Comma);
337            self.rbits.unparse_tokens(tokens);
338            tokens.push(PtxToken::Semicolon);
339        }
340    }
341
342    impl PtxUnparser for CvtFrnd2ReluSatfiniteBf16F32 {
343        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
344            push_opcode(tokens, "cvt");
345            match &self.frnd2 {
346                Frnd2::Rn => {
347                    push_directive(tokens, "rn");
348                }
349                Frnd2::Rz => {
350                    push_directive(tokens, "rz");
351                }
352            }
353            if self.relu {
354                push_directive(tokens, "relu");
355            }
356            if self.satfinite {
357                push_directive(tokens, "satfinite");
358            }
359            push_directive(tokens, "bf16");
360            push_directive(tokens, "f32");
361            self.d.unparse_tokens(tokens);
362            tokens.push(PtxToken::Comma);
363            self.a.unparse_tokens(tokens);
364            tokens.push(PtxToken::Semicolon);
365        }
366    }
367
368    impl PtxUnparser for CvtFrnd2ReluSatfiniteBf16x2F32 {
369        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
370            push_opcode(tokens, "cvt");
371            match &self.frnd2 {
372                Frnd2::Rn => {
373                    push_directive(tokens, "rn");
374                }
375                Frnd2::Rz => {
376                    push_directive(tokens, "rz");
377                }
378            }
379            if self.relu {
380                push_directive(tokens, "relu");
381            }
382            if self.satfinite {
383                push_directive(tokens, "satfinite");
384            }
385            push_directive(tokens, "bf16x2");
386            push_directive(tokens, "f32");
387            self.d.unparse_tokens(tokens);
388            tokens.push(PtxToken::Comma);
389            self.a.unparse_tokens(tokens);
390            tokens.push(PtxToken::Comma);
391            self.b.unparse_tokens(tokens);
392            tokens.push(PtxToken::Semicolon);
393        }
394    }
395
396    impl PtxUnparser for CvtRsReluSatfiniteBf16x2F32 {
397        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
398            push_opcode(tokens, "cvt");
399            push_directive(tokens, "rs");
400            if self.relu {
401                push_directive(tokens, "relu");
402            }
403            if self.satfinite {
404                push_directive(tokens, "satfinite");
405            }
406            push_directive(tokens, "bf16x2");
407            push_directive(tokens, "f32");
408            self.d.unparse_tokens(tokens);
409            tokens.push(PtxToken::Comma);
410            self.a.unparse_tokens(tokens);
411            tokens.push(PtxToken::Comma);
412            self.b.unparse_tokens(tokens);
413            tokens.push(PtxToken::Comma);
414            self.rbits.unparse_tokens(tokens);
415            tokens.push(PtxToken::Semicolon);
416        }
417    }
418
419    impl PtxUnparser for CvtRnaSatfiniteTf32F32 {
420        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
421            push_opcode(tokens, "cvt");
422            push_directive(tokens, "rna");
423            if self.satfinite {
424                push_directive(tokens, "satfinite");
425            }
426            push_directive(tokens, "tf32");
427            push_directive(tokens, "f32");
428            self.d.unparse_tokens(tokens);
429            tokens.push(PtxToken::Comma);
430            self.a.unparse_tokens(tokens);
431            tokens.push(PtxToken::Semicolon);
432        }
433    }
434
435    impl PtxUnparser for CvtFrnd2SatfiniteReluTf32F32 {
436        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
437            push_opcode(tokens, "cvt");
438            match &self.frnd2 {
439                Frnd2::Rn => {
440                    push_directive(tokens, "rn");
441                }
442                Frnd2::Rz => {
443                    push_directive(tokens, "rz");
444                }
445            }
446            if self.satfinite {
447                push_directive(tokens, "satfinite");
448            }
449            if self.relu {
450                push_directive(tokens, "relu");
451            }
452            push_directive(tokens, "tf32");
453            push_directive(tokens, "f32");
454            self.d.unparse_tokens(tokens);
455            tokens.push(PtxToken::Comma);
456            self.a.unparse_tokens(tokens);
457            tokens.push(PtxToken::Semicolon);
458        }
459    }
460
461    impl PtxUnparser for CvtRnSatfiniteReluF8x2typeF32 {
462        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
463            push_opcode(tokens, "cvt");
464            push_directive(tokens, "rn");
465            push_directive(tokens, "satfinite");
466            if self.relu {
467                push_directive(tokens, "relu");
468            }
469            match &self.f8x2type {
470                F8x2type::E4m3x2 => {
471                    push_directive(tokens, "e4m3x2");
472                }
473                F8x2type::E5m2x2 => {
474                    push_directive(tokens, "e5m2x2");
475                }
476            }
477            push_directive(tokens, "f32");
478            self.d.unparse_tokens(tokens);
479            tokens.push(PtxToken::Comma);
480            self.a.unparse_tokens(tokens);
481            tokens.push(PtxToken::Comma);
482            self.b.unparse_tokens(tokens);
483            tokens.push(PtxToken::Semicolon);
484        }
485    }
486
487    impl PtxUnparser for CvtRnSatfiniteReluF8x2typeF16x2 {
488        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
489            push_opcode(tokens, "cvt");
490            push_directive(tokens, "rn");
491            push_directive(tokens, "satfinite");
492            if self.relu {
493                push_directive(tokens, "relu");
494            }
495            match &self.f8x2type {
496                F8x2type::E4m3x2 => {
497                    push_directive(tokens, "e4m3x2");
498                }
499                F8x2type::E5m2x2 => {
500                    push_directive(tokens, "e5m2x2");
501                }
502            }
503            push_directive(tokens, "f16x2");
504            self.d.unparse_tokens(tokens);
505            tokens.push(PtxToken::Comma);
506            self.a.unparse_tokens(tokens);
507            tokens.push(PtxToken::Semicolon);
508        }
509    }
510
511    impl PtxUnparser for CvtRnReluF16x2F8x2type {
512        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
513            push_opcode(tokens, "cvt");
514            push_directive(tokens, "rn");
515            if self.relu {
516                push_directive(tokens, "relu");
517            }
518            push_directive(tokens, "f16x2");
519            match &self.f8x2type {
520                F8x2type::E4m3x2 => {
521                    push_directive(tokens, "e4m3x2");
522                }
523                F8x2type::E5m2x2 => {
524                    push_directive(tokens, "e5m2x2");
525                }
526            }
527            self.d.unparse_tokens(tokens);
528            tokens.push(PtxToken::Comma);
529            self.a.unparse_tokens(tokens);
530            tokens.push(PtxToken::Semicolon);
531        }
532    }
533
534    impl PtxUnparser for CvtRsReluSatfiniteF8x4typeF32 {
535        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
536            push_opcode(tokens, "cvt");
537            push_directive(tokens, "rs");
538            if self.relu {
539                push_directive(tokens, "relu");
540            }
541            push_directive(tokens, "satfinite");
542            match &self.f8x4type {
543                F8x4type::E4m3x4 => {
544                    push_directive(tokens, "e4m3x4");
545                }
546                F8x4type::E5m2x4 => {
547                    push_directive(tokens, "e5m2x4");
548                }
549            }
550            push_directive(tokens, "f32");
551            self.d.unparse_tokens(tokens);
552            tokens.push(PtxToken::Comma);
553            self.a.unparse_tokens(tokens);
554            tokens.push(PtxToken::Comma);
555            self.rbits.unparse_tokens(tokens);
556            tokens.push(PtxToken::Semicolon);
557        }
558    }
559
560    impl PtxUnparser for CvtRnSatfiniteReluF4x2typeF32 {
561        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
562            push_opcode(tokens, "cvt");
563            push_directive(tokens, "rn");
564            push_directive(tokens, "satfinite");
565            if self.relu {
566                push_directive(tokens, "relu");
567            }
568            match &self.f4x2type {
569                F4x2type::E2m1x2 => {
570                    push_directive(tokens, "e2m1x2");
571                }
572            }
573            push_directive(tokens, "f32");
574            self.d.unparse_tokens(tokens);
575            tokens.push(PtxToken::Comma);
576            self.a.unparse_tokens(tokens);
577            tokens.push(PtxToken::Comma);
578            self.b.unparse_tokens(tokens);
579            tokens.push(PtxToken::Semicolon);
580        }
581    }
582
583    impl PtxUnparser for CvtRnReluF16x2F4x2type {
584        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
585            push_opcode(tokens, "cvt");
586            push_directive(tokens, "rn");
587            if self.relu {
588                push_directive(tokens, "relu");
589            }
590            push_directive(tokens, "f16x2");
591            match &self.f4x2type {
592                F4x2type::E2m1x2 => {
593                    push_directive(tokens, "e2m1x2");
594                }
595            }
596            self.d.unparse_tokens(tokens);
597            tokens.push(PtxToken::Comma);
598            self.a.unparse_tokens(tokens);
599            tokens.push(PtxToken::Semicolon);
600        }
601    }
602
603    impl PtxUnparser for CvtRsReluSatfiniteF4x4typeF32 {
604        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
605            push_opcode(tokens, "cvt");
606            push_directive(tokens, "rs");
607            if self.relu {
608                push_directive(tokens, "relu");
609            }
610            push_directive(tokens, "satfinite");
611            match &self.f4x4type {
612                F4x4type::E2m1x4 => {
613                    push_directive(tokens, "e2m1x4");
614                }
615            }
616            push_directive(tokens, "f32");
617            self.d.unparse_tokens(tokens);
618            tokens.push(PtxToken::Comma);
619            self.a.unparse_tokens(tokens);
620            tokens.push(PtxToken::Comma);
621            self.rbits.unparse_tokens(tokens);
622            tokens.push(PtxToken::Semicolon);
623        }
624    }
625
626    impl PtxUnparser for CvtRnSatfiniteReluF6x2typeF32 {
627        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
628            push_opcode(tokens, "cvt");
629            push_directive(tokens, "rn");
630            push_directive(tokens, "satfinite");
631            if self.relu {
632                push_directive(tokens, "relu");
633            }
634            match &self.f6x2type {
635                F6x2type::E2m3x2 => {
636                    push_directive(tokens, "e2m3x2");
637                }
638                F6x2type::E3m2x2 => {
639                    push_directive(tokens, "e3m2x2");
640                }
641            }
642            push_directive(tokens, "f32");
643            self.d.unparse_tokens(tokens);
644            tokens.push(PtxToken::Comma);
645            self.a.unparse_tokens(tokens);
646            tokens.push(PtxToken::Comma);
647            self.b.unparse_tokens(tokens);
648            tokens.push(PtxToken::Semicolon);
649        }
650    }
651
652    impl PtxUnparser for CvtRnReluF16x2F6x2type {
653        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
654            push_opcode(tokens, "cvt");
655            push_directive(tokens, "rn");
656            if self.relu {
657                push_directive(tokens, "relu");
658            }
659            push_directive(tokens, "f16x2");
660            match &self.f6x2type {
661                F6x2type::E2m3x2 => {
662                    push_directive(tokens, "e2m3x2");
663                }
664                F6x2type::E3m2x2 => {
665                    push_directive(tokens, "e3m2x2");
666                }
667            }
668            self.d.unparse_tokens(tokens);
669            tokens.push(PtxToken::Comma);
670            self.a.unparse_tokens(tokens);
671            tokens.push(PtxToken::Semicolon);
672        }
673    }
674
675    impl PtxUnparser for CvtRsReluSatfiniteF6x4typeF32 {
676        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
677            push_opcode(tokens, "cvt");
678            push_directive(tokens, "rs");
679            if self.relu {
680                push_directive(tokens, "relu");
681            }
682            push_directive(tokens, "satfinite");
683            match &self.f6x4type {
684                F6x4type::E2m3x4 => {
685                    push_directive(tokens, "e2m3x4");
686                }
687                F6x4type::E3m2x4 => {
688                    push_directive(tokens, "e3m2x4");
689                }
690            }
691            push_directive(tokens, "f32");
692            self.d.unparse_tokens(tokens);
693            tokens.push(PtxToken::Comma);
694            self.a.unparse_tokens(tokens);
695            tokens.push(PtxToken::Comma);
696            self.rbits.unparse_tokens(tokens);
697            tokens.push(PtxToken::Semicolon);
698        }
699    }
700
701    impl PtxUnparser for CvtFrnd3SatfiniteUe8m0x2F32 {
702        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
703            push_opcode(tokens, "cvt");
704            match &self.frnd3 {
705                Frnd3::Rz => {
706                    push_directive(tokens, "rz");
707                }
708                Frnd3::Rp => {
709                    push_directive(tokens, "rp");
710                }
711            }
712            if self.satfinite {
713                push_directive(tokens, "satfinite");
714            }
715            push_directive(tokens, "ue8m0x2");
716            push_directive(tokens, "f32");
717            self.d.unparse_tokens(tokens);
718            tokens.push(PtxToken::Comma);
719            self.a.unparse_tokens(tokens);
720            tokens.push(PtxToken::Comma);
721            self.b.unparse_tokens(tokens);
722            tokens.push(PtxToken::Semicolon);
723        }
724    }
725
726    impl PtxUnparser for CvtFrnd3SatfiniteUe8m0x2Bf16x2 {
727        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
728            push_opcode(tokens, "cvt");
729            match &self.frnd3 {
730                Frnd3::Rz => {
731                    push_directive(tokens, "rz");
732                }
733                Frnd3::Rp => {
734                    push_directive(tokens, "rp");
735                }
736            }
737            if self.satfinite {
738                push_directive(tokens, "satfinite");
739            }
740            push_directive(tokens, "ue8m0x2");
741            push_directive(tokens, "bf16x2");
742            self.d.unparse_tokens(tokens);
743            tokens.push(PtxToken::Comma);
744            self.a.unparse_tokens(tokens);
745            tokens.push(PtxToken::Semicolon);
746        }
747    }
748
749    impl PtxUnparser for CvtRnBf16x2Ue8m0x2 {
750        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
751            push_opcode(tokens, "cvt");
752            push_directive(tokens, "rn");
753            push_directive(tokens, "bf16x2");
754            push_directive(tokens, "ue8m0x2");
755            self.d.unparse_tokens(tokens);
756            tokens.push(PtxToken::Comma);
757            self.a.unparse_tokens(tokens);
758            tokens.push(PtxToken::Semicolon);
759        }
760    }
761}
ptx_parser/unparser/instruction/cvt.rs

ptx_parser/unparser/instruction/
cvt.rs
