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