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