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