ptx_parser/unparser/instruction/
vop.rs

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

ptx_parser/unparser/instruction/
vop.rs
