ptx_parser/unparser/instruction/
set.rs

1//! Original PTX specification:
2//!
3//! set.CmpOp{.ftz}.dtype.stype         d, a, b;
4//! set.CmpOp.BoolOp{.ftz}.dtype.stype  d, a, b, {!}c;
5//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs,
6//! .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
7//! .BoolOp = { .and, .or, .xor };
8//! .dtype  = { .u32, .s32, .f32 };
9//! .stype  = { .b16, .b32, .b64,
10//! .u16, .u32, .u64,
11//! .s16, .s32, .s64,
12//! .f32, .f64 };
13//! -------------------------------------------------------------
14//! set.CmpOp{.ftz}.f16.stype            d, a, b;
15//! set.CmpOp.BoolOp{.ftz}.f16.stype     d, a, b, {!}c;
16//! set.CmpOp.bf16.stype                 d, a, b;
17//! set.CmpOp.BoolOp.bf16.stype          d, a, b, {!}c;
18//! set.CmpOp{.ftz}.dtype.f16            d, a, b;
19//! set.CmpOp.BoolOp{.ftz}.dtype.f16     d, a, b, {!}c;
20//! .dtype  = { .u16, .s16, .u32, .s32};
21//! ----------------------------------------------------
22//! // Alternate floating point type:
23//! set.CmpOp.dtype.bf16                 d, a, b;
24//! set.CmpOp.BoolOp.dtype.bf16          d, a, b, {!}c;
25//! .dtype  = { .u16, .s16, .u32, .s32};
26//! ----------------------------------------------------
27//! // Alternate floating point type:
28//! set.CmpOp{.ftz}.dtype.f16x2          d, a, b;
29//! set.CmpOp.BoolOp{.ftz}.dtype.f16x2   d, a, b, {!}c;
30//! .dtype  = { .f16x2, .u32, .s32};
31//! ----------------------------------------------------
32//! // Alternate floating point type:
33//! set.CmpOp.dtype.bf16x2               d, a, b;
34//! set.CmpOp.BoolOp.dtype.bf16x2        d, a, b, {!}c;
35//! .dtype  = { .bf16x2, .u32, .s32};
36//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge,
37//! .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
38//! .BoolOp = { .and, .or, .xor };
39//! .stype  = { .b16, .b32, .b64,
40//! .u16, .u32, .u64,
41//! .s16, .s32, .s64,
42//! .f16, .f32, .f64};
43
44#![allow(unused)]
45
46use crate::lexer::PtxToken;
47use crate::unparser::{PtxUnparser, common::*};
48
49pub mod section_0 {
50    use super::*;
51    use crate::r#type::instruction::set::section_0::*;
52
53    impl PtxUnparser for SetCmpopFtzDtypeStype {
54        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
55            self.unparse_tokens_mode(tokens, false);
56        }
57        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
58            push_opcode(tokens, "set");
59            match &self.cmpop {
60                Cmpop::Equ => {
61                    push_directive(tokens, "equ");
62                }
63                Cmpop::Neu => {
64                    push_directive(tokens, "neu");
65                }
66                Cmpop::Ltu => {
67                    push_directive(tokens, "ltu");
68                }
69                Cmpop::Leu => {
70                    push_directive(tokens, "leu");
71                }
72                Cmpop::Gtu => {
73                    push_directive(tokens, "gtu");
74                }
75                Cmpop::Geu => {
76                    push_directive(tokens, "geu");
77                }
78                Cmpop::Num => {
79                    push_directive(tokens, "num");
80                }
81                Cmpop::Nan => {
82                    push_directive(tokens, "nan");
83                }
84                Cmpop::Eq => {
85                    push_directive(tokens, "eq");
86                }
87                Cmpop::Ne => {
88                    push_directive(tokens, "ne");
89                }
90                Cmpop::Lt => {
91                    push_directive(tokens, "lt");
92                }
93                Cmpop::Le => {
94                    push_directive(tokens, "le");
95                }
96                Cmpop::Gt => {
97                    push_directive(tokens, "gt");
98                }
99                Cmpop::Ge => {
100                    push_directive(tokens, "ge");
101                }
102                Cmpop::Lo => {
103                    push_directive(tokens, "lo");
104                }
105                Cmpop::Ls => {
106                    push_directive(tokens, "ls");
107                }
108                Cmpop::Hi => {
109                    push_directive(tokens, "hi");
110                }
111                Cmpop::Hs => {
112                    push_directive(tokens, "hs");
113                }
114            }
115            if self.ftz {
116                push_directive(tokens, "ftz");
117            }
118            match &self.dtype {
119                Dtype::U32 => {
120                    push_directive(tokens, "u32");
121                }
122                Dtype::S32 => {
123                    push_directive(tokens, "s32");
124                }
125                Dtype::F32 => {
126                    push_directive(tokens, "f32");
127                }
128            }
129            match &self.stype {
130                Stype::B16 => {
131                    push_directive(tokens, "b16");
132                }
133                Stype::B32 => {
134                    push_directive(tokens, "b32");
135                }
136                Stype::B64 => {
137                    push_directive(tokens, "b64");
138                }
139                Stype::U16 => {
140                    push_directive(tokens, "u16");
141                }
142                Stype::U32 => {
143                    push_directive(tokens, "u32");
144                }
145                Stype::U64 => {
146                    push_directive(tokens, "u64");
147                }
148                Stype::S16 => {
149                    push_directive(tokens, "s16");
150                }
151                Stype::S32 => {
152                    push_directive(tokens, "s32");
153                }
154                Stype::S64 => {
155                    push_directive(tokens, "s64");
156                }
157                Stype::F32 => {
158                    push_directive(tokens, "f32");
159                }
160                Stype::F64 => {
161                    push_directive(tokens, "f64");
162                }
163            }
164            if spaced {
165                tokens.push(PtxToken::Space);
166            }
167            self.d.unparse_tokens_mode(tokens, spaced);
168            tokens.push(PtxToken::Comma);
169            if spaced {
170                tokens.push(PtxToken::Space);
171            }
172            self.a.unparse_tokens_mode(tokens, spaced);
173            tokens.push(PtxToken::Comma);
174            if spaced {
175                tokens.push(PtxToken::Space);
176            }
177            self.b.unparse_tokens_mode(tokens, spaced);
178            tokens.push(PtxToken::Semicolon);
179            if spaced {
180                tokens.push(PtxToken::Newline);
181            }
182        }
183    }
184
185    impl PtxUnparser for SetCmpopBoolopFtzDtypeStype {
186        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
187            self.unparse_tokens_mode(tokens, false);
188        }
189        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
190            push_opcode(tokens, "set");
191            match &self.cmpop {
192                Cmpop::Equ => {
193                    push_directive(tokens, "equ");
194                }
195                Cmpop::Neu => {
196                    push_directive(tokens, "neu");
197                }
198                Cmpop::Ltu => {
199                    push_directive(tokens, "ltu");
200                }
201                Cmpop::Leu => {
202                    push_directive(tokens, "leu");
203                }
204                Cmpop::Gtu => {
205                    push_directive(tokens, "gtu");
206                }
207                Cmpop::Geu => {
208                    push_directive(tokens, "geu");
209                }
210                Cmpop::Num => {
211                    push_directive(tokens, "num");
212                }
213                Cmpop::Nan => {
214                    push_directive(tokens, "nan");
215                }
216                Cmpop::Eq => {
217                    push_directive(tokens, "eq");
218                }
219                Cmpop::Ne => {
220                    push_directive(tokens, "ne");
221                }
222                Cmpop::Lt => {
223                    push_directive(tokens, "lt");
224                }
225                Cmpop::Le => {
226                    push_directive(tokens, "le");
227                }
228                Cmpop::Gt => {
229                    push_directive(tokens, "gt");
230                }
231                Cmpop::Ge => {
232                    push_directive(tokens, "ge");
233                }
234                Cmpop::Lo => {
235                    push_directive(tokens, "lo");
236                }
237                Cmpop::Ls => {
238                    push_directive(tokens, "ls");
239                }
240                Cmpop::Hi => {
241                    push_directive(tokens, "hi");
242                }
243                Cmpop::Hs => {
244                    push_directive(tokens, "hs");
245                }
246            }
247            match &self.boolop {
248                Boolop::And => {
249                    push_directive(tokens, "and");
250                }
251                Boolop::Xor => {
252                    push_directive(tokens, "xor");
253                }
254                Boolop::Or => {
255                    push_directive(tokens, "or");
256                }
257            }
258            if self.ftz {
259                push_directive(tokens, "ftz");
260            }
261            match &self.dtype {
262                Dtype::U32 => {
263                    push_directive(tokens, "u32");
264                }
265                Dtype::S32 => {
266                    push_directive(tokens, "s32");
267                }
268                Dtype::F32 => {
269                    push_directive(tokens, "f32");
270                }
271            }
272            match &self.stype {
273                Stype::B16 => {
274                    push_directive(tokens, "b16");
275                }
276                Stype::B32 => {
277                    push_directive(tokens, "b32");
278                }
279                Stype::B64 => {
280                    push_directive(tokens, "b64");
281                }
282                Stype::U16 => {
283                    push_directive(tokens, "u16");
284                }
285                Stype::U32 => {
286                    push_directive(tokens, "u32");
287                }
288                Stype::U64 => {
289                    push_directive(tokens, "u64");
290                }
291                Stype::S16 => {
292                    push_directive(tokens, "s16");
293                }
294                Stype::S32 => {
295                    push_directive(tokens, "s32");
296                }
297                Stype::S64 => {
298                    push_directive(tokens, "s64");
299                }
300                Stype::F32 => {
301                    push_directive(tokens, "f32");
302                }
303                Stype::F64 => {
304                    push_directive(tokens, "f64");
305                }
306            }
307            if spaced {
308                tokens.push(PtxToken::Space);
309            }
310            self.d.unparse_tokens_mode(tokens, spaced);
311            tokens.push(PtxToken::Comma);
312            if spaced {
313                tokens.push(PtxToken::Space);
314            }
315            self.a.unparse_tokens_mode(tokens, spaced);
316            tokens.push(PtxToken::Comma);
317            if spaced {
318                tokens.push(PtxToken::Space);
319            }
320            self.b.unparse_tokens_mode(tokens, spaced);
321            tokens.push(PtxToken::Comma);
322            if self.c_op {
323                tokens.push(PtxToken::Exclaim);
324            }
325            if spaced {
326                tokens.push(PtxToken::Space);
327            }
328            self.c.unparse_tokens_mode(tokens, spaced);
329            tokens.push(PtxToken::Semicolon);
330            if spaced {
331                tokens.push(PtxToken::Newline);
332            }
333        }
334    }
335}
336
337pub mod section_1 {
338    use super::*;
339    use crate::r#type::instruction::set::section_1::*;
340
341    impl PtxUnparser for SetCmpopFtzF16Stype {
342        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
343            self.unparse_tokens_mode(tokens, false);
344        }
345        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
346            push_opcode(tokens, "set");
347            match &self.cmpop {
348                Cmpop::Equ => {
349                    push_directive(tokens, "equ");
350                }
351                Cmpop::Neu => {
352                    push_directive(tokens, "neu");
353                }
354                Cmpop::Ltu => {
355                    push_directive(tokens, "ltu");
356                }
357                Cmpop::Leu => {
358                    push_directive(tokens, "leu");
359                }
360                Cmpop::Gtu => {
361                    push_directive(tokens, "gtu");
362                }
363                Cmpop::Geu => {
364                    push_directive(tokens, "geu");
365                }
366                Cmpop::Num => {
367                    push_directive(tokens, "num");
368                }
369                Cmpop::Nan => {
370                    push_directive(tokens, "nan");
371                }
372                Cmpop::Eq => {
373                    push_directive(tokens, "eq");
374                }
375                Cmpop::Ne => {
376                    push_directive(tokens, "ne");
377                }
378                Cmpop::Lt => {
379                    push_directive(tokens, "lt");
380                }
381                Cmpop::Le => {
382                    push_directive(tokens, "le");
383                }
384                Cmpop::Gt => {
385                    push_directive(tokens, "gt");
386                }
387                Cmpop::Ge => {
388                    push_directive(tokens, "ge");
389                }
390                Cmpop::Lo => {
391                    push_directive(tokens, "lo");
392                }
393                Cmpop::Ls => {
394                    push_directive(tokens, "ls");
395                }
396                Cmpop::Hi => {
397                    push_directive(tokens, "hi");
398                }
399                Cmpop::Hs => {
400                    push_directive(tokens, "hs");
401                }
402            }
403            if self.ftz {
404                push_directive(tokens, "ftz");
405            }
406            push_directive(tokens, "f16");
407            match &self.stype {
408                Stype::B16 => {
409                    push_directive(tokens, "b16");
410                }
411                Stype::B32 => {
412                    push_directive(tokens, "b32");
413                }
414                Stype::B64 => {
415                    push_directive(tokens, "b64");
416                }
417                Stype::U16 => {
418                    push_directive(tokens, "u16");
419                }
420                Stype::U32 => {
421                    push_directive(tokens, "u32");
422                }
423                Stype::U64 => {
424                    push_directive(tokens, "u64");
425                }
426                Stype::S16 => {
427                    push_directive(tokens, "s16");
428                }
429                Stype::S32 => {
430                    push_directive(tokens, "s32");
431                }
432                Stype::S64 => {
433                    push_directive(tokens, "s64");
434                }
435                Stype::F32 => {
436                    push_directive(tokens, "f32");
437                }
438                Stype::F64 => {
439                    push_directive(tokens, "f64");
440                }
441            }
442            if spaced {
443                tokens.push(PtxToken::Space);
444            }
445            self.d.unparse_tokens_mode(tokens, spaced);
446            tokens.push(PtxToken::Comma);
447            if spaced {
448                tokens.push(PtxToken::Space);
449            }
450            self.a.unparse_tokens_mode(tokens, spaced);
451            tokens.push(PtxToken::Comma);
452            if spaced {
453                tokens.push(PtxToken::Space);
454            }
455            self.b.unparse_tokens_mode(tokens, spaced);
456            tokens.push(PtxToken::Semicolon);
457            if spaced {
458                tokens.push(PtxToken::Newline);
459            }
460        }
461    }
462
463    impl PtxUnparser for SetCmpopBoolopFtzF16Stype {
464        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
465            self.unparse_tokens_mode(tokens, false);
466        }
467        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
468            push_opcode(tokens, "set");
469            match &self.cmpop {
470                Cmpop::Equ => {
471                    push_directive(tokens, "equ");
472                }
473                Cmpop::Neu => {
474                    push_directive(tokens, "neu");
475                }
476                Cmpop::Ltu => {
477                    push_directive(tokens, "ltu");
478                }
479                Cmpop::Leu => {
480                    push_directive(tokens, "leu");
481                }
482                Cmpop::Gtu => {
483                    push_directive(tokens, "gtu");
484                }
485                Cmpop::Geu => {
486                    push_directive(tokens, "geu");
487                }
488                Cmpop::Num => {
489                    push_directive(tokens, "num");
490                }
491                Cmpop::Nan => {
492                    push_directive(tokens, "nan");
493                }
494                Cmpop::Eq => {
495                    push_directive(tokens, "eq");
496                }
497                Cmpop::Ne => {
498                    push_directive(tokens, "ne");
499                }
500                Cmpop::Lt => {
501                    push_directive(tokens, "lt");
502                }
503                Cmpop::Le => {
504                    push_directive(tokens, "le");
505                }
506                Cmpop::Gt => {
507                    push_directive(tokens, "gt");
508                }
509                Cmpop::Ge => {
510                    push_directive(tokens, "ge");
511                }
512                Cmpop::Lo => {
513                    push_directive(tokens, "lo");
514                }
515                Cmpop::Ls => {
516                    push_directive(tokens, "ls");
517                }
518                Cmpop::Hi => {
519                    push_directive(tokens, "hi");
520                }
521                Cmpop::Hs => {
522                    push_directive(tokens, "hs");
523                }
524            }
525            match &self.boolop {
526                Boolop::And => {
527                    push_directive(tokens, "and");
528                }
529                Boolop::Xor => {
530                    push_directive(tokens, "xor");
531                }
532                Boolop::Or => {
533                    push_directive(tokens, "or");
534                }
535            }
536            if self.ftz {
537                push_directive(tokens, "ftz");
538            }
539            push_directive(tokens, "f16");
540            match &self.stype {
541                Stype::B16 => {
542                    push_directive(tokens, "b16");
543                }
544                Stype::B32 => {
545                    push_directive(tokens, "b32");
546                }
547                Stype::B64 => {
548                    push_directive(tokens, "b64");
549                }
550                Stype::U16 => {
551                    push_directive(tokens, "u16");
552                }
553                Stype::U32 => {
554                    push_directive(tokens, "u32");
555                }
556                Stype::U64 => {
557                    push_directive(tokens, "u64");
558                }
559                Stype::S16 => {
560                    push_directive(tokens, "s16");
561                }
562                Stype::S32 => {
563                    push_directive(tokens, "s32");
564                }
565                Stype::S64 => {
566                    push_directive(tokens, "s64");
567                }
568                Stype::F32 => {
569                    push_directive(tokens, "f32");
570                }
571                Stype::F64 => {
572                    push_directive(tokens, "f64");
573                }
574            }
575            if spaced {
576                tokens.push(PtxToken::Space);
577            }
578            self.d.unparse_tokens_mode(tokens, spaced);
579            tokens.push(PtxToken::Comma);
580            if spaced {
581                tokens.push(PtxToken::Space);
582            }
583            self.a.unparse_tokens_mode(tokens, spaced);
584            tokens.push(PtxToken::Comma);
585            if spaced {
586                tokens.push(PtxToken::Space);
587            }
588            self.b.unparse_tokens_mode(tokens, spaced);
589            tokens.push(PtxToken::Comma);
590            if self.c_op {
591                tokens.push(PtxToken::Exclaim);
592            }
593            if spaced {
594                tokens.push(PtxToken::Space);
595            }
596            self.c.unparse_tokens_mode(tokens, spaced);
597            tokens.push(PtxToken::Semicolon);
598            if spaced {
599                tokens.push(PtxToken::Newline);
600            }
601        }
602    }
603
604    impl PtxUnparser for SetCmpopBf16Stype {
605        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
606            self.unparse_tokens_mode(tokens, false);
607        }
608        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
609            push_opcode(tokens, "set");
610            match &self.cmpop {
611                Cmpop::Equ => {
612                    push_directive(tokens, "equ");
613                }
614                Cmpop::Neu => {
615                    push_directive(tokens, "neu");
616                }
617                Cmpop::Ltu => {
618                    push_directive(tokens, "ltu");
619                }
620                Cmpop::Leu => {
621                    push_directive(tokens, "leu");
622                }
623                Cmpop::Gtu => {
624                    push_directive(tokens, "gtu");
625                }
626                Cmpop::Geu => {
627                    push_directive(tokens, "geu");
628                }
629                Cmpop::Num => {
630                    push_directive(tokens, "num");
631                }
632                Cmpop::Nan => {
633                    push_directive(tokens, "nan");
634                }
635                Cmpop::Eq => {
636                    push_directive(tokens, "eq");
637                }
638                Cmpop::Ne => {
639                    push_directive(tokens, "ne");
640                }
641                Cmpop::Lt => {
642                    push_directive(tokens, "lt");
643                }
644                Cmpop::Le => {
645                    push_directive(tokens, "le");
646                }
647                Cmpop::Gt => {
648                    push_directive(tokens, "gt");
649                }
650                Cmpop::Ge => {
651                    push_directive(tokens, "ge");
652                }
653                Cmpop::Lo => {
654                    push_directive(tokens, "lo");
655                }
656                Cmpop::Ls => {
657                    push_directive(tokens, "ls");
658                }
659                Cmpop::Hi => {
660                    push_directive(tokens, "hi");
661                }
662                Cmpop::Hs => {
663                    push_directive(tokens, "hs");
664                }
665            }
666            push_directive(tokens, "bf16");
667            match &self.stype {
668                Stype::B16 => {
669                    push_directive(tokens, "b16");
670                }
671                Stype::B32 => {
672                    push_directive(tokens, "b32");
673                }
674                Stype::B64 => {
675                    push_directive(tokens, "b64");
676                }
677                Stype::U16 => {
678                    push_directive(tokens, "u16");
679                }
680                Stype::U32 => {
681                    push_directive(tokens, "u32");
682                }
683                Stype::U64 => {
684                    push_directive(tokens, "u64");
685                }
686                Stype::S16 => {
687                    push_directive(tokens, "s16");
688                }
689                Stype::S32 => {
690                    push_directive(tokens, "s32");
691                }
692                Stype::S64 => {
693                    push_directive(tokens, "s64");
694                }
695                Stype::F32 => {
696                    push_directive(tokens, "f32");
697                }
698                Stype::F64 => {
699                    push_directive(tokens, "f64");
700                }
701            }
702            if spaced {
703                tokens.push(PtxToken::Space);
704            }
705            self.d.unparse_tokens_mode(tokens, spaced);
706            tokens.push(PtxToken::Comma);
707            if spaced {
708                tokens.push(PtxToken::Space);
709            }
710            self.a.unparse_tokens_mode(tokens, spaced);
711            tokens.push(PtxToken::Comma);
712            if spaced {
713                tokens.push(PtxToken::Space);
714            }
715            self.b.unparse_tokens_mode(tokens, spaced);
716            tokens.push(PtxToken::Semicolon);
717            if spaced {
718                tokens.push(PtxToken::Newline);
719            }
720        }
721    }
722
723    impl PtxUnparser for SetCmpopBoolopBf16Stype {
724        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
725            self.unparse_tokens_mode(tokens, false);
726        }
727        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
728            push_opcode(tokens, "set");
729            match &self.cmpop {
730                Cmpop::Equ => {
731                    push_directive(tokens, "equ");
732                }
733                Cmpop::Neu => {
734                    push_directive(tokens, "neu");
735                }
736                Cmpop::Ltu => {
737                    push_directive(tokens, "ltu");
738                }
739                Cmpop::Leu => {
740                    push_directive(tokens, "leu");
741                }
742                Cmpop::Gtu => {
743                    push_directive(tokens, "gtu");
744                }
745                Cmpop::Geu => {
746                    push_directive(tokens, "geu");
747                }
748                Cmpop::Num => {
749                    push_directive(tokens, "num");
750                }
751                Cmpop::Nan => {
752                    push_directive(tokens, "nan");
753                }
754                Cmpop::Eq => {
755                    push_directive(tokens, "eq");
756                }
757                Cmpop::Ne => {
758                    push_directive(tokens, "ne");
759                }
760                Cmpop::Lt => {
761                    push_directive(tokens, "lt");
762                }
763                Cmpop::Le => {
764                    push_directive(tokens, "le");
765                }
766                Cmpop::Gt => {
767                    push_directive(tokens, "gt");
768                }
769                Cmpop::Ge => {
770                    push_directive(tokens, "ge");
771                }
772                Cmpop::Lo => {
773                    push_directive(tokens, "lo");
774                }
775                Cmpop::Ls => {
776                    push_directive(tokens, "ls");
777                }
778                Cmpop::Hi => {
779                    push_directive(tokens, "hi");
780                }
781                Cmpop::Hs => {
782                    push_directive(tokens, "hs");
783                }
784            }
785            match &self.boolop {
786                Boolop::And => {
787                    push_directive(tokens, "and");
788                }
789                Boolop::Xor => {
790                    push_directive(tokens, "xor");
791                }
792                Boolop::Or => {
793                    push_directive(tokens, "or");
794                }
795            }
796            push_directive(tokens, "bf16");
797            match &self.stype {
798                Stype::B16 => {
799                    push_directive(tokens, "b16");
800                }
801                Stype::B32 => {
802                    push_directive(tokens, "b32");
803                }
804                Stype::B64 => {
805                    push_directive(tokens, "b64");
806                }
807                Stype::U16 => {
808                    push_directive(tokens, "u16");
809                }
810                Stype::U32 => {
811                    push_directive(tokens, "u32");
812                }
813                Stype::U64 => {
814                    push_directive(tokens, "u64");
815                }
816                Stype::S16 => {
817                    push_directive(tokens, "s16");
818                }
819                Stype::S32 => {
820                    push_directive(tokens, "s32");
821                }
822                Stype::S64 => {
823                    push_directive(tokens, "s64");
824                }
825                Stype::F32 => {
826                    push_directive(tokens, "f32");
827                }
828                Stype::F64 => {
829                    push_directive(tokens, "f64");
830                }
831            }
832            if spaced {
833                tokens.push(PtxToken::Space);
834            }
835            self.d.unparse_tokens_mode(tokens, spaced);
836            tokens.push(PtxToken::Comma);
837            if spaced {
838                tokens.push(PtxToken::Space);
839            }
840            self.a.unparse_tokens_mode(tokens, spaced);
841            tokens.push(PtxToken::Comma);
842            if spaced {
843                tokens.push(PtxToken::Space);
844            }
845            self.b.unparse_tokens_mode(tokens, spaced);
846            tokens.push(PtxToken::Comma);
847            if self.c_op {
848                tokens.push(PtxToken::Exclaim);
849            }
850            if spaced {
851                tokens.push(PtxToken::Space);
852            }
853            self.c.unparse_tokens_mode(tokens, spaced);
854            tokens.push(PtxToken::Semicolon);
855            if spaced {
856                tokens.push(PtxToken::Newline);
857            }
858        }
859    }
860
861    impl PtxUnparser for SetCmpopFtzDtypeF16 {
862        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
863            self.unparse_tokens_mode(tokens, false);
864        }
865        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
866            push_opcode(tokens, "set");
867            match &self.cmpop {
868                Cmpop::Equ => {
869                    push_directive(tokens, "equ");
870                }
871                Cmpop::Neu => {
872                    push_directive(tokens, "neu");
873                }
874                Cmpop::Ltu => {
875                    push_directive(tokens, "ltu");
876                }
877                Cmpop::Leu => {
878                    push_directive(tokens, "leu");
879                }
880                Cmpop::Gtu => {
881                    push_directive(tokens, "gtu");
882                }
883                Cmpop::Geu => {
884                    push_directive(tokens, "geu");
885                }
886                Cmpop::Num => {
887                    push_directive(tokens, "num");
888                }
889                Cmpop::Nan => {
890                    push_directive(tokens, "nan");
891                }
892                Cmpop::Eq => {
893                    push_directive(tokens, "eq");
894                }
895                Cmpop::Ne => {
896                    push_directive(tokens, "ne");
897                }
898                Cmpop::Lt => {
899                    push_directive(tokens, "lt");
900                }
901                Cmpop::Le => {
902                    push_directive(tokens, "le");
903                }
904                Cmpop::Gt => {
905                    push_directive(tokens, "gt");
906                }
907                Cmpop::Ge => {
908                    push_directive(tokens, "ge");
909                }
910                Cmpop::Lo => {
911                    push_directive(tokens, "lo");
912                }
913                Cmpop::Ls => {
914                    push_directive(tokens, "ls");
915                }
916                Cmpop::Hi => {
917                    push_directive(tokens, "hi");
918                }
919                Cmpop::Hs => {
920                    push_directive(tokens, "hs");
921                }
922            }
923            if self.ftz {
924                push_directive(tokens, "ftz");
925            }
926            match &self.dtype {
927                Dtype::U16 => {
928                    push_directive(tokens, "u16");
929                }
930                Dtype::S16 => {
931                    push_directive(tokens, "s16");
932                }
933                Dtype::U32 => {
934                    push_directive(tokens, "u32");
935                }
936                Dtype::S32 => {
937                    push_directive(tokens, "s32");
938                }
939            }
940            push_directive(tokens, "f16");
941            if spaced {
942                tokens.push(PtxToken::Space);
943            }
944            self.d.unparse_tokens_mode(tokens, spaced);
945            tokens.push(PtxToken::Comma);
946            if spaced {
947                tokens.push(PtxToken::Space);
948            }
949            self.a.unparse_tokens_mode(tokens, spaced);
950            tokens.push(PtxToken::Comma);
951            if spaced {
952                tokens.push(PtxToken::Space);
953            }
954            self.b.unparse_tokens_mode(tokens, spaced);
955            tokens.push(PtxToken::Semicolon);
956            if spaced {
957                tokens.push(PtxToken::Newline);
958            }
959        }
960    }
961
962    impl PtxUnparser for SetCmpopBoolopFtzDtypeF16 {
963        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
964            self.unparse_tokens_mode(tokens, false);
965        }
966        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
967            push_opcode(tokens, "set");
968            match &self.cmpop {
969                Cmpop::Equ => {
970                    push_directive(tokens, "equ");
971                }
972                Cmpop::Neu => {
973                    push_directive(tokens, "neu");
974                }
975                Cmpop::Ltu => {
976                    push_directive(tokens, "ltu");
977                }
978                Cmpop::Leu => {
979                    push_directive(tokens, "leu");
980                }
981                Cmpop::Gtu => {
982                    push_directive(tokens, "gtu");
983                }
984                Cmpop::Geu => {
985                    push_directive(tokens, "geu");
986                }
987                Cmpop::Num => {
988                    push_directive(tokens, "num");
989                }
990                Cmpop::Nan => {
991                    push_directive(tokens, "nan");
992                }
993                Cmpop::Eq => {
994                    push_directive(tokens, "eq");
995                }
996                Cmpop::Ne => {
997                    push_directive(tokens, "ne");
998                }
999                Cmpop::Lt => {
1000                    push_directive(tokens, "lt");
1001                }
1002                Cmpop::Le => {
1003                    push_directive(tokens, "le");
1004                }
1005                Cmpop::Gt => {
1006                    push_directive(tokens, "gt");
1007                }
1008                Cmpop::Ge => {
1009                    push_directive(tokens, "ge");
1010                }
1011                Cmpop::Lo => {
1012                    push_directive(tokens, "lo");
1013                }
1014                Cmpop::Ls => {
1015                    push_directive(tokens, "ls");
1016                }
1017                Cmpop::Hi => {
1018                    push_directive(tokens, "hi");
1019                }
1020                Cmpop::Hs => {
1021                    push_directive(tokens, "hs");
1022                }
1023            }
1024            match &self.boolop {
1025                Boolop::And => {
1026                    push_directive(tokens, "and");
1027                }
1028                Boolop::Xor => {
1029                    push_directive(tokens, "xor");
1030                }
1031                Boolop::Or => {
1032                    push_directive(tokens, "or");
1033                }
1034            }
1035            if self.ftz {
1036                push_directive(tokens, "ftz");
1037            }
1038            match &self.dtype {
1039                Dtype::U16 => {
1040                    push_directive(tokens, "u16");
1041                }
1042                Dtype::S16 => {
1043                    push_directive(tokens, "s16");
1044                }
1045                Dtype::U32 => {
1046                    push_directive(tokens, "u32");
1047                }
1048                Dtype::S32 => {
1049                    push_directive(tokens, "s32");
1050                }
1051            }
1052            push_directive(tokens, "f16");
1053            if spaced {
1054                tokens.push(PtxToken::Space);
1055            }
1056            self.d.unparse_tokens_mode(tokens, spaced);
1057            tokens.push(PtxToken::Comma);
1058            if spaced {
1059                tokens.push(PtxToken::Space);
1060            }
1061            self.a.unparse_tokens_mode(tokens, spaced);
1062            tokens.push(PtxToken::Comma);
1063            if spaced {
1064                tokens.push(PtxToken::Space);
1065            }
1066            self.b.unparse_tokens_mode(tokens, spaced);
1067            tokens.push(PtxToken::Comma);
1068            if self.c_op {
1069                tokens.push(PtxToken::Exclaim);
1070            }
1071            if spaced {
1072                tokens.push(PtxToken::Space);
1073            }
1074            self.c.unparse_tokens_mode(tokens, spaced);
1075            tokens.push(PtxToken::Semicolon);
1076            if spaced {
1077                tokens.push(PtxToken::Newline);
1078            }
1079        }
1080    }
1081}
1082
1083pub mod section_2 {
1084    use super::*;
1085    use crate::r#type::instruction::set::section_2::*;
1086
1087    impl PtxUnparser for SetCmpopDtypeBf16 {
1088        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1089            self.unparse_tokens_mode(tokens, false);
1090        }
1091        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1092            push_opcode(tokens, "set");
1093            match &self.cmpop {
1094                Cmpop::Equ => {
1095                    push_directive(tokens, "equ");
1096                }
1097                Cmpop::Neu => {
1098                    push_directive(tokens, "neu");
1099                }
1100                Cmpop::Ltu => {
1101                    push_directive(tokens, "ltu");
1102                }
1103                Cmpop::Leu => {
1104                    push_directive(tokens, "leu");
1105                }
1106                Cmpop::Gtu => {
1107                    push_directive(tokens, "gtu");
1108                }
1109                Cmpop::Geu => {
1110                    push_directive(tokens, "geu");
1111                }
1112                Cmpop::Num => {
1113                    push_directive(tokens, "num");
1114                }
1115                Cmpop::Nan => {
1116                    push_directive(tokens, "nan");
1117                }
1118                Cmpop::Eq => {
1119                    push_directive(tokens, "eq");
1120                }
1121                Cmpop::Ne => {
1122                    push_directive(tokens, "ne");
1123                }
1124                Cmpop::Lt => {
1125                    push_directive(tokens, "lt");
1126                }
1127                Cmpop::Le => {
1128                    push_directive(tokens, "le");
1129                }
1130                Cmpop::Gt => {
1131                    push_directive(tokens, "gt");
1132                }
1133                Cmpop::Ge => {
1134                    push_directive(tokens, "ge");
1135                }
1136                Cmpop::Lo => {
1137                    push_directive(tokens, "lo");
1138                }
1139                Cmpop::Ls => {
1140                    push_directive(tokens, "ls");
1141                }
1142                Cmpop::Hi => {
1143                    push_directive(tokens, "hi");
1144                }
1145                Cmpop::Hs => {
1146                    push_directive(tokens, "hs");
1147                }
1148            }
1149            match &self.dtype {
1150                Dtype::U16 => {
1151                    push_directive(tokens, "u16");
1152                }
1153                Dtype::S16 => {
1154                    push_directive(tokens, "s16");
1155                }
1156                Dtype::U32 => {
1157                    push_directive(tokens, "u32");
1158                }
1159                Dtype::S32 => {
1160                    push_directive(tokens, "s32");
1161                }
1162            }
1163            push_directive(tokens, "bf16");
1164            if spaced {
1165                tokens.push(PtxToken::Space);
1166            }
1167            self.d.unparse_tokens_mode(tokens, spaced);
1168            tokens.push(PtxToken::Comma);
1169            if spaced {
1170                tokens.push(PtxToken::Space);
1171            }
1172            self.a.unparse_tokens_mode(tokens, spaced);
1173            tokens.push(PtxToken::Comma);
1174            if spaced {
1175                tokens.push(PtxToken::Space);
1176            }
1177            self.b.unparse_tokens_mode(tokens, spaced);
1178            tokens.push(PtxToken::Semicolon);
1179            if spaced {
1180                tokens.push(PtxToken::Newline);
1181            }
1182        }
1183    }
1184
1185    impl PtxUnparser for SetCmpopBoolopDtypeBf16 {
1186        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1187            self.unparse_tokens_mode(tokens, false);
1188        }
1189        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1190            push_opcode(tokens, "set");
1191            match &self.cmpop {
1192                Cmpop::Equ => {
1193                    push_directive(tokens, "equ");
1194                }
1195                Cmpop::Neu => {
1196                    push_directive(tokens, "neu");
1197                }
1198                Cmpop::Ltu => {
1199                    push_directive(tokens, "ltu");
1200                }
1201                Cmpop::Leu => {
1202                    push_directive(tokens, "leu");
1203                }
1204                Cmpop::Gtu => {
1205                    push_directive(tokens, "gtu");
1206                }
1207                Cmpop::Geu => {
1208                    push_directive(tokens, "geu");
1209                }
1210                Cmpop::Num => {
1211                    push_directive(tokens, "num");
1212                }
1213                Cmpop::Nan => {
1214                    push_directive(tokens, "nan");
1215                }
1216                Cmpop::Eq => {
1217                    push_directive(tokens, "eq");
1218                }
1219                Cmpop::Ne => {
1220                    push_directive(tokens, "ne");
1221                }
1222                Cmpop::Lt => {
1223                    push_directive(tokens, "lt");
1224                }
1225                Cmpop::Le => {
1226                    push_directive(tokens, "le");
1227                }
1228                Cmpop::Gt => {
1229                    push_directive(tokens, "gt");
1230                }
1231                Cmpop::Ge => {
1232                    push_directive(tokens, "ge");
1233                }
1234                Cmpop::Lo => {
1235                    push_directive(tokens, "lo");
1236                }
1237                Cmpop::Ls => {
1238                    push_directive(tokens, "ls");
1239                }
1240                Cmpop::Hi => {
1241                    push_directive(tokens, "hi");
1242                }
1243                Cmpop::Hs => {
1244                    push_directive(tokens, "hs");
1245                }
1246            }
1247            match &self.boolop {
1248                Boolop::And => {
1249                    push_directive(tokens, "and");
1250                }
1251                Boolop::Xor => {
1252                    push_directive(tokens, "xor");
1253                }
1254                Boolop::Or => {
1255                    push_directive(tokens, "or");
1256                }
1257            }
1258            match &self.dtype {
1259                Dtype::U16 => {
1260                    push_directive(tokens, "u16");
1261                }
1262                Dtype::S16 => {
1263                    push_directive(tokens, "s16");
1264                }
1265                Dtype::U32 => {
1266                    push_directive(tokens, "u32");
1267                }
1268                Dtype::S32 => {
1269                    push_directive(tokens, "s32");
1270                }
1271            }
1272            push_directive(tokens, "bf16");
1273            if spaced {
1274                tokens.push(PtxToken::Space);
1275            }
1276            self.d.unparse_tokens_mode(tokens, spaced);
1277            tokens.push(PtxToken::Comma);
1278            if spaced {
1279                tokens.push(PtxToken::Space);
1280            }
1281            self.a.unparse_tokens_mode(tokens, spaced);
1282            tokens.push(PtxToken::Comma);
1283            if spaced {
1284                tokens.push(PtxToken::Space);
1285            }
1286            self.b.unparse_tokens_mode(tokens, spaced);
1287            tokens.push(PtxToken::Comma);
1288            if self.c_op {
1289                tokens.push(PtxToken::Exclaim);
1290            }
1291            if spaced {
1292                tokens.push(PtxToken::Space);
1293            }
1294            self.c.unparse_tokens_mode(tokens, spaced);
1295            tokens.push(PtxToken::Semicolon);
1296            if spaced {
1297                tokens.push(PtxToken::Newline);
1298            }
1299        }
1300    }
1301}
1302
1303pub mod section_3 {
1304    use super::*;
1305    use crate::r#type::instruction::set::section_3::*;
1306
1307    impl PtxUnparser for SetCmpopFtzDtypeF16x2 {
1308        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1309            self.unparse_tokens_mode(tokens, false);
1310        }
1311        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1312            push_opcode(tokens, "set");
1313            match &self.cmpop {
1314                Cmpop::Equ => {
1315                    push_directive(tokens, "equ");
1316                }
1317                Cmpop::Neu => {
1318                    push_directive(tokens, "neu");
1319                }
1320                Cmpop::Ltu => {
1321                    push_directive(tokens, "ltu");
1322                }
1323                Cmpop::Leu => {
1324                    push_directive(tokens, "leu");
1325                }
1326                Cmpop::Gtu => {
1327                    push_directive(tokens, "gtu");
1328                }
1329                Cmpop::Geu => {
1330                    push_directive(tokens, "geu");
1331                }
1332                Cmpop::Num => {
1333                    push_directive(tokens, "num");
1334                }
1335                Cmpop::Nan => {
1336                    push_directive(tokens, "nan");
1337                }
1338                Cmpop::Eq => {
1339                    push_directive(tokens, "eq");
1340                }
1341                Cmpop::Ne => {
1342                    push_directive(tokens, "ne");
1343                }
1344                Cmpop::Lt => {
1345                    push_directive(tokens, "lt");
1346                }
1347                Cmpop::Le => {
1348                    push_directive(tokens, "le");
1349                }
1350                Cmpop::Gt => {
1351                    push_directive(tokens, "gt");
1352                }
1353                Cmpop::Ge => {
1354                    push_directive(tokens, "ge");
1355                }
1356                Cmpop::Lo => {
1357                    push_directive(tokens, "lo");
1358                }
1359                Cmpop::Ls => {
1360                    push_directive(tokens, "ls");
1361                }
1362                Cmpop::Hi => {
1363                    push_directive(tokens, "hi");
1364                }
1365                Cmpop::Hs => {
1366                    push_directive(tokens, "hs");
1367                }
1368            }
1369            if self.ftz {
1370                push_directive(tokens, "ftz");
1371            }
1372            match &self.dtype {
1373                Dtype::F16x2 => {
1374                    push_directive(tokens, "f16x2");
1375                }
1376                Dtype::U32 => {
1377                    push_directive(tokens, "u32");
1378                }
1379                Dtype::S32 => {
1380                    push_directive(tokens, "s32");
1381                }
1382            }
1383            push_directive(tokens, "f16x2");
1384            if spaced {
1385                tokens.push(PtxToken::Space);
1386            }
1387            self.d.unparse_tokens_mode(tokens, spaced);
1388            tokens.push(PtxToken::Comma);
1389            if spaced {
1390                tokens.push(PtxToken::Space);
1391            }
1392            self.a.unparse_tokens_mode(tokens, spaced);
1393            tokens.push(PtxToken::Comma);
1394            if spaced {
1395                tokens.push(PtxToken::Space);
1396            }
1397            self.b.unparse_tokens_mode(tokens, spaced);
1398            tokens.push(PtxToken::Semicolon);
1399            if spaced {
1400                tokens.push(PtxToken::Newline);
1401            }
1402        }
1403    }
1404
1405    impl PtxUnparser for SetCmpopBoolopFtzDtypeF16x2 {
1406        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1407            self.unparse_tokens_mode(tokens, false);
1408        }
1409        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1410            push_opcode(tokens, "set");
1411            match &self.cmpop {
1412                Cmpop::Equ => {
1413                    push_directive(tokens, "equ");
1414                }
1415                Cmpop::Neu => {
1416                    push_directive(tokens, "neu");
1417                }
1418                Cmpop::Ltu => {
1419                    push_directive(tokens, "ltu");
1420                }
1421                Cmpop::Leu => {
1422                    push_directive(tokens, "leu");
1423                }
1424                Cmpop::Gtu => {
1425                    push_directive(tokens, "gtu");
1426                }
1427                Cmpop::Geu => {
1428                    push_directive(tokens, "geu");
1429                }
1430                Cmpop::Num => {
1431                    push_directive(tokens, "num");
1432                }
1433                Cmpop::Nan => {
1434                    push_directive(tokens, "nan");
1435                }
1436                Cmpop::Eq => {
1437                    push_directive(tokens, "eq");
1438                }
1439                Cmpop::Ne => {
1440                    push_directive(tokens, "ne");
1441                }
1442                Cmpop::Lt => {
1443                    push_directive(tokens, "lt");
1444                }
1445                Cmpop::Le => {
1446                    push_directive(tokens, "le");
1447                }
1448                Cmpop::Gt => {
1449                    push_directive(tokens, "gt");
1450                }
1451                Cmpop::Ge => {
1452                    push_directive(tokens, "ge");
1453                }
1454                Cmpop::Lo => {
1455                    push_directive(tokens, "lo");
1456                }
1457                Cmpop::Ls => {
1458                    push_directive(tokens, "ls");
1459                }
1460                Cmpop::Hi => {
1461                    push_directive(tokens, "hi");
1462                }
1463                Cmpop::Hs => {
1464                    push_directive(tokens, "hs");
1465                }
1466            }
1467            match &self.boolop {
1468                Boolop::And => {
1469                    push_directive(tokens, "and");
1470                }
1471                Boolop::Xor => {
1472                    push_directive(tokens, "xor");
1473                }
1474                Boolop::Or => {
1475                    push_directive(tokens, "or");
1476                }
1477            }
1478            if self.ftz {
1479                push_directive(tokens, "ftz");
1480            }
1481            match &self.dtype {
1482                Dtype::F16x2 => {
1483                    push_directive(tokens, "f16x2");
1484                }
1485                Dtype::U32 => {
1486                    push_directive(tokens, "u32");
1487                }
1488                Dtype::S32 => {
1489                    push_directive(tokens, "s32");
1490                }
1491            }
1492            push_directive(tokens, "f16x2");
1493            if spaced {
1494                tokens.push(PtxToken::Space);
1495            }
1496            self.d.unparse_tokens_mode(tokens, spaced);
1497            tokens.push(PtxToken::Comma);
1498            if spaced {
1499                tokens.push(PtxToken::Space);
1500            }
1501            self.a.unparse_tokens_mode(tokens, spaced);
1502            tokens.push(PtxToken::Comma);
1503            if spaced {
1504                tokens.push(PtxToken::Space);
1505            }
1506            self.b.unparse_tokens_mode(tokens, spaced);
1507            tokens.push(PtxToken::Comma);
1508            if self.c_op {
1509                tokens.push(PtxToken::Exclaim);
1510            }
1511            if spaced {
1512                tokens.push(PtxToken::Space);
1513            }
1514            self.c.unparse_tokens_mode(tokens, spaced);
1515            tokens.push(PtxToken::Semicolon);
1516            if spaced {
1517                tokens.push(PtxToken::Newline);
1518            }
1519        }
1520    }
1521}
1522
1523pub mod section_4 {
1524    use super::*;
1525    use crate::r#type::instruction::set::section_4::*;
1526
1527    impl PtxUnparser for SetCmpopDtypeBf16x2 {
1528        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1529            self.unparse_tokens_mode(tokens, false);
1530        }
1531        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1532            push_opcode(tokens, "set");
1533            match &self.cmpop {
1534                Cmpop::Equ => {
1535                    push_directive(tokens, "equ");
1536                }
1537                Cmpop::Neu => {
1538                    push_directive(tokens, "neu");
1539                }
1540                Cmpop::Ltu => {
1541                    push_directive(tokens, "ltu");
1542                }
1543                Cmpop::Leu => {
1544                    push_directive(tokens, "leu");
1545                }
1546                Cmpop::Gtu => {
1547                    push_directive(tokens, "gtu");
1548                }
1549                Cmpop::Geu => {
1550                    push_directive(tokens, "geu");
1551                }
1552                Cmpop::Num => {
1553                    push_directive(tokens, "num");
1554                }
1555                Cmpop::Nan => {
1556                    push_directive(tokens, "nan");
1557                }
1558                Cmpop::Eq => {
1559                    push_directive(tokens, "eq");
1560                }
1561                Cmpop::Ne => {
1562                    push_directive(tokens, "ne");
1563                }
1564                Cmpop::Lt => {
1565                    push_directive(tokens, "lt");
1566                }
1567                Cmpop::Le => {
1568                    push_directive(tokens, "le");
1569                }
1570                Cmpop::Gt => {
1571                    push_directive(tokens, "gt");
1572                }
1573                Cmpop::Ge => {
1574                    push_directive(tokens, "ge");
1575                }
1576            }
1577            match &self.dtype {
1578                Dtype::Bf16x2 => {
1579                    push_directive(tokens, "bf16x2");
1580                }
1581                Dtype::U32 => {
1582                    push_directive(tokens, "u32");
1583                }
1584                Dtype::S32 => {
1585                    push_directive(tokens, "s32");
1586                }
1587            }
1588            push_directive(tokens, "bf16x2");
1589            if spaced {
1590                tokens.push(PtxToken::Space);
1591            }
1592            self.d.unparse_tokens_mode(tokens, spaced);
1593            tokens.push(PtxToken::Comma);
1594            if spaced {
1595                tokens.push(PtxToken::Space);
1596            }
1597            self.a.unparse_tokens_mode(tokens, spaced);
1598            tokens.push(PtxToken::Comma);
1599            if spaced {
1600                tokens.push(PtxToken::Space);
1601            }
1602            self.b.unparse_tokens_mode(tokens, spaced);
1603            tokens.push(PtxToken::Semicolon);
1604            if spaced {
1605                tokens.push(PtxToken::Newline);
1606            }
1607        }
1608    }
1609
1610    impl PtxUnparser for SetCmpopBoolopDtypeBf16x2 {
1611        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
1612            self.unparse_tokens_mode(tokens, false);
1613        }
1614        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
1615            push_opcode(tokens, "set");
1616            match &self.cmpop {
1617                Cmpop::Equ => {
1618                    push_directive(tokens, "equ");
1619                }
1620                Cmpop::Neu => {
1621                    push_directive(tokens, "neu");
1622                }
1623                Cmpop::Ltu => {
1624                    push_directive(tokens, "ltu");
1625                }
1626                Cmpop::Leu => {
1627                    push_directive(tokens, "leu");
1628                }
1629                Cmpop::Gtu => {
1630                    push_directive(tokens, "gtu");
1631                }
1632                Cmpop::Geu => {
1633                    push_directive(tokens, "geu");
1634                }
1635                Cmpop::Num => {
1636                    push_directive(tokens, "num");
1637                }
1638                Cmpop::Nan => {
1639                    push_directive(tokens, "nan");
1640                }
1641                Cmpop::Eq => {
1642                    push_directive(tokens, "eq");
1643                }
1644                Cmpop::Ne => {
1645                    push_directive(tokens, "ne");
1646                }
1647                Cmpop::Lt => {
1648                    push_directive(tokens, "lt");
1649                }
1650                Cmpop::Le => {
1651                    push_directive(tokens, "le");
1652                }
1653                Cmpop::Gt => {
1654                    push_directive(tokens, "gt");
1655                }
1656                Cmpop::Ge => {
1657                    push_directive(tokens, "ge");
1658                }
1659            }
1660            match &self.boolop {
1661                Boolop::And => {
1662                    push_directive(tokens, "and");
1663                }
1664                Boolop::Xor => {
1665                    push_directive(tokens, "xor");
1666                }
1667                Boolop::Or => {
1668                    push_directive(tokens, "or");
1669                }
1670            }
1671            match &self.dtype {
1672                Dtype::Bf16x2 => {
1673                    push_directive(tokens, "bf16x2");
1674                }
1675                Dtype::U32 => {
1676                    push_directive(tokens, "u32");
1677                }
1678                Dtype::S32 => {
1679                    push_directive(tokens, "s32");
1680                }
1681            }
1682            push_directive(tokens, "bf16x2");
1683            if spaced {
1684                tokens.push(PtxToken::Space);
1685            }
1686            self.d.unparse_tokens_mode(tokens, spaced);
1687            tokens.push(PtxToken::Comma);
1688            if spaced {
1689                tokens.push(PtxToken::Space);
1690            }
1691            self.a.unparse_tokens_mode(tokens, spaced);
1692            tokens.push(PtxToken::Comma);
1693            if spaced {
1694                tokens.push(PtxToken::Space);
1695            }
1696            self.b.unparse_tokens_mode(tokens, spaced);
1697            tokens.push(PtxToken::Comma);
1698            if self.c_op {
1699                tokens.push(PtxToken::Exclaim);
1700            }
1701            if spaced {
1702                tokens.push(PtxToken::Space);
1703            }
1704            self.c.unparse_tokens_mode(tokens, spaced);
1705            tokens.push(PtxToken::Semicolon);
1706            if spaced {
1707                tokens.push(PtxToken::Newline);
1708            }
1709        }
1710    }
1711}
ptx_parser/unparser/instruction/set.rs

ptx_parser/unparser/instruction/
set.rs
