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

ptx_parser/unparser/instruction/
set.rs
