ptx_parser/unparser/instruction/
vop4.rs

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

ptx_parser/unparser/instruction/
vop4.rs
