ptx_parser/unparser/instruction/
vsh.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vop.dtype.atype.u32{.sat}.mode       d, a{.asel}, b{.bsel};
5//! vop.dtype.atype.u32{.sat}.mode.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vop.dtype.atype.u32{.sat}.mode  d.dsel, a{.asel}, b{.bsel}, c;
8//! vop   = { vshl, vshr };
9//! .dtype = .atype = { .u32, .s32 };
10//! .mode  = { .clamp, .wrap };
11//! .dsel  = .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
12//! .op2   = { .add, .min, .max };
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::vsh::section_0::*;
22
23    impl PtxUnparser for VshlDtypeAtypeU32SatMode {
24        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
25            self.unparse_tokens_mode(tokens, false);
26        }
27        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
28            push_opcode(tokens, "vshl");
29            match &self.dtype {
30                Dtype::U32 => {
31                    push_directive(tokens, "u32");
32                }
33                Dtype::S32 => {
34                    push_directive(tokens, "s32");
35                }
36            }
37            match &self.atype {
38                Atype::U32 => {
39                    push_directive(tokens, "u32");
40                }
41                Atype::S32 => {
42                    push_directive(tokens, "s32");
43                }
44            }
45            push_directive(tokens, "u32");
46            if self.sat {
47                push_directive(tokens, "sat");
48            }
49            match &self.mode {
50                Mode::Clamp => {
51                    push_directive(tokens, "clamp");
52                }
53                Mode::Wrap => {
54                    push_directive(tokens, "wrap");
55                }
56            }
57            if spaced {
58                tokens.push(PtxToken::Space);
59            }
60            self.d.unparse_tokens_mode(tokens, spaced);
61            tokens.push(PtxToken::Comma);
62            if spaced {
63                tokens.push(PtxToken::Space);
64            }
65            self.a.unparse_tokens_mode(tokens, spaced);
66            if let Some(asel_0) = self.asel.as_ref() {
67                match asel_0 {
68                    Asel::B0 => {
69                        push_directive(tokens, "b0");
70                    }
71                    Asel::B1 => {
72                        push_directive(tokens, "b1");
73                    }
74                    Asel::B2 => {
75                        push_directive(tokens, "b2");
76                    }
77                    Asel::B3 => {
78                        push_directive(tokens, "b3");
79                    }
80                    Asel::H0 => {
81                        push_directive(tokens, "h0");
82                    }
83                    Asel::H1 => {
84                        push_directive(tokens, "h1");
85                    }
86                }
87            }
88            tokens.push(PtxToken::Comma);
89            if spaced {
90                tokens.push(PtxToken::Space);
91            }
92            self.b.unparse_tokens_mode(tokens, spaced);
93            if let Some(bsel_1) = self.bsel.as_ref() {
94                match bsel_1 {
95                    Bsel::B0 => {
96                        push_directive(tokens, "b0");
97                    }
98                    Bsel::B1 => {
99                        push_directive(tokens, "b1");
100                    }
101                    Bsel::B2 => {
102                        push_directive(tokens, "b2");
103                    }
104                    Bsel::B3 => {
105                        push_directive(tokens, "b3");
106                    }
107                    Bsel::H0 => {
108                        push_directive(tokens, "h0");
109                    }
110                    Bsel::H1 => {
111                        push_directive(tokens, "h1");
112                    }
113                }
114            }
115            tokens.push(PtxToken::Semicolon);
116            if spaced {
117                tokens.push(PtxToken::Newline);
118            }
119        }
120    }
121
122    impl PtxUnparser for VshrDtypeAtypeU32SatMode {
123        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
124            self.unparse_tokens_mode(tokens, false);
125        }
126        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
127            push_opcode(tokens, "vshr");
128            match &self.dtype {
129                Dtype::U32 => {
130                    push_directive(tokens, "u32");
131                }
132                Dtype::S32 => {
133                    push_directive(tokens, "s32");
134                }
135            }
136            match &self.atype {
137                Atype::U32 => {
138                    push_directive(tokens, "u32");
139                }
140                Atype::S32 => {
141                    push_directive(tokens, "s32");
142                }
143            }
144            push_directive(tokens, "u32");
145            if self.sat {
146                push_directive(tokens, "sat");
147            }
148            match &self.mode {
149                Mode::Clamp => {
150                    push_directive(tokens, "clamp");
151                }
152                Mode::Wrap => {
153                    push_directive(tokens, "wrap");
154                }
155            }
156            if spaced {
157                tokens.push(PtxToken::Space);
158            }
159            self.d.unparse_tokens_mode(tokens, spaced);
160            tokens.push(PtxToken::Comma);
161            if spaced {
162                tokens.push(PtxToken::Space);
163            }
164            self.a.unparse_tokens_mode(tokens, spaced);
165            if let Some(asel_2) = self.asel.as_ref() {
166                match asel_2 {
167                    Asel::B0 => {
168                        push_directive(tokens, "b0");
169                    }
170                    Asel::B1 => {
171                        push_directive(tokens, "b1");
172                    }
173                    Asel::B2 => {
174                        push_directive(tokens, "b2");
175                    }
176                    Asel::B3 => {
177                        push_directive(tokens, "b3");
178                    }
179                    Asel::H0 => {
180                        push_directive(tokens, "h0");
181                    }
182                    Asel::H1 => {
183                        push_directive(tokens, "h1");
184                    }
185                }
186            }
187            tokens.push(PtxToken::Comma);
188            if spaced {
189                tokens.push(PtxToken::Space);
190            }
191            self.b.unparse_tokens_mode(tokens, spaced);
192            if let Some(bsel_3) = self.bsel.as_ref() {
193                match bsel_3 {
194                    Bsel::B0 => {
195                        push_directive(tokens, "b0");
196                    }
197                    Bsel::B1 => {
198                        push_directive(tokens, "b1");
199                    }
200                    Bsel::B2 => {
201                        push_directive(tokens, "b2");
202                    }
203                    Bsel::B3 => {
204                        push_directive(tokens, "b3");
205                    }
206                    Bsel::H0 => {
207                        push_directive(tokens, "h0");
208                    }
209                    Bsel::H1 => {
210                        push_directive(tokens, "h1");
211                    }
212                }
213            }
214            tokens.push(PtxToken::Semicolon);
215            if spaced {
216                tokens.push(PtxToken::Newline);
217            }
218        }
219    }
220
221    impl PtxUnparser for VshlDtypeAtypeU32SatModeOp2 {
222        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
223            self.unparse_tokens_mode(tokens, false);
224        }
225        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
226            push_opcode(tokens, "vshl");
227            match &self.dtype {
228                Dtype::U32 => {
229                    push_directive(tokens, "u32");
230                }
231                Dtype::S32 => {
232                    push_directive(tokens, "s32");
233                }
234            }
235            match &self.atype {
236                Atype::U32 => {
237                    push_directive(tokens, "u32");
238                }
239                Atype::S32 => {
240                    push_directive(tokens, "s32");
241                }
242            }
243            push_directive(tokens, "u32");
244            if self.sat {
245                push_directive(tokens, "sat");
246            }
247            match &self.mode {
248                Mode::Clamp => {
249                    push_directive(tokens, "clamp");
250                }
251                Mode::Wrap => {
252                    push_directive(tokens, "wrap");
253                }
254            }
255            match &self.op2 {
256                Op2::Add => {
257                    push_directive(tokens, "add");
258                }
259                Op2::Min => {
260                    push_directive(tokens, "min");
261                }
262                Op2::Max => {
263                    push_directive(tokens, "max");
264                }
265            }
266            if spaced {
267                tokens.push(PtxToken::Space);
268            }
269            self.d.unparse_tokens_mode(tokens, spaced);
270            tokens.push(PtxToken::Comma);
271            if spaced {
272                tokens.push(PtxToken::Space);
273            }
274            self.a.unparse_tokens_mode(tokens, spaced);
275            if let Some(asel_4) = self.asel.as_ref() {
276                match asel_4 {
277                    Asel::B0 => {
278                        push_directive(tokens, "b0");
279                    }
280                    Asel::B1 => {
281                        push_directive(tokens, "b1");
282                    }
283                    Asel::B2 => {
284                        push_directive(tokens, "b2");
285                    }
286                    Asel::B3 => {
287                        push_directive(tokens, "b3");
288                    }
289                    Asel::H0 => {
290                        push_directive(tokens, "h0");
291                    }
292                    Asel::H1 => {
293                        push_directive(tokens, "h1");
294                    }
295                }
296            }
297            tokens.push(PtxToken::Comma);
298            if spaced {
299                tokens.push(PtxToken::Space);
300            }
301            self.b.unparse_tokens_mode(tokens, spaced);
302            if let Some(bsel_5) = self.bsel.as_ref() {
303                match bsel_5 {
304                    Bsel::B0 => {
305                        push_directive(tokens, "b0");
306                    }
307                    Bsel::B1 => {
308                        push_directive(tokens, "b1");
309                    }
310                    Bsel::B2 => {
311                        push_directive(tokens, "b2");
312                    }
313                    Bsel::B3 => {
314                        push_directive(tokens, "b3");
315                    }
316                    Bsel::H0 => {
317                        push_directive(tokens, "h0");
318                    }
319                    Bsel::H1 => {
320                        push_directive(tokens, "h1");
321                    }
322                }
323            }
324            tokens.push(PtxToken::Comma);
325            if spaced {
326                tokens.push(PtxToken::Space);
327            }
328            self.c.unparse_tokens_mode(tokens, spaced);
329            tokens.push(PtxToken::Semicolon);
330            if spaced {
331                tokens.push(PtxToken::Newline);
332            }
333        }
334    }
335
336    impl PtxUnparser for VshrDtypeAtypeU32SatModeOp2 {
337        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
338            self.unparse_tokens_mode(tokens, false);
339        }
340        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
341            push_opcode(tokens, "vshr");
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            push_directive(tokens, "u32");
359            if self.sat {
360                push_directive(tokens, "sat");
361            }
362            match &self.mode {
363                Mode::Clamp => {
364                    push_directive(tokens, "clamp");
365                }
366                Mode::Wrap => {
367                    push_directive(tokens, "wrap");
368                }
369            }
370            match &self.op2 {
371                Op2::Add => {
372                    push_directive(tokens, "add");
373                }
374                Op2::Min => {
375                    push_directive(tokens, "min");
376                }
377                Op2::Max => {
378                    push_directive(tokens, "max");
379                }
380            }
381            if spaced {
382                tokens.push(PtxToken::Space);
383            }
384            self.d.unparse_tokens_mode(tokens, spaced);
385            tokens.push(PtxToken::Comma);
386            if spaced {
387                tokens.push(PtxToken::Space);
388            }
389            self.a.unparse_tokens_mode(tokens, spaced);
390            if let Some(asel_6) = self.asel.as_ref() {
391                match asel_6 {
392                    Asel::B0 => {
393                        push_directive(tokens, "b0");
394                    }
395                    Asel::B1 => {
396                        push_directive(tokens, "b1");
397                    }
398                    Asel::B2 => {
399                        push_directive(tokens, "b2");
400                    }
401                    Asel::B3 => {
402                        push_directive(tokens, "b3");
403                    }
404                    Asel::H0 => {
405                        push_directive(tokens, "h0");
406                    }
407                    Asel::H1 => {
408                        push_directive(tokens, "h1");
409                    }
410                }
411            }
412            tokens.push(PtxToken::Comma);
413            if spaced {
414                tokens.push(PtxToken::Space);
415            }
416            self.b.unparse_tokens_mode(tokens, spaced);
417            if let Some(bsel_7) = self.bsel.as_ref() {
418                match bsel_7 {
419                    Bsel::B0 => {
420                        push_directive(tokens, "b0");
421                    }
422                    Bsel::B1 => {
423                        push_directive(tokens, "b1");
424                    }
425                    Bsel::B2 => {
426                        push_directive(tokens, "b2");
427                    }
428                    Bsel::B3 => {
429                        push_directive(tokens, "b3");
430                    }
431                    Bsel::H0 => {
432                        push_directive(tokens, "h0");
433                    }
434                    Bsel::H1 => {
435                        push_directive(tokens, "h1");
436                    }
437                }
438            }
439            tokens.push(PtxToken::Comma);
440            if spaced {
441                tokens.push(PtxToken::Space);
442            }
443            self.c.unparse_tokens_mode(tokens, spaced);
444            tokens.push(PtxToken::Semicolon);
445            if spaced {
446                tokens.push(PtxToken::Newline);
447            }
448        }
449    }
450
451    impl PtxUnparser for VshlDtypeAtypeU32SatMode1 {
452        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
453            self.unparse_tokens_mode(tokens, false);
454        }
455        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
456            push_opcode(tokens, "vshl");
457            match &self.dtype {
458                Dtype::U32 => {
459                    push_directive(tokens, "u32");
460                }
461                Dtype::S32 => {
462                    push_directive(tokens, "s32");
463                }
464            }
465            match &self.atype {
466                Atype::U32 => {
467                    push_directive(tokens, "u32");
468                }
469                Atype::S32 => {
470                    push_directive(tokens, "s32");
471                }
472            }
473            push_directive(tokens, "u32");
474            if self.sat {
475                push_directive(tokens, "sat");
476            }
477            match &self.mode {
478                Mode::Clamp => {
479                    push_directive(tokens, "clamp");
480                }
481                Mode::Wrap => {
482                    push_directive(tokens, "wrap");
483                }
484            }
485            if spaced {
486                tokens.push(PtxToken::Space);
487            }
488            self.d.unparse_tokens_mode(tokens, spaced);
489            match &self.dsel {
490                Dsel::B0 => {
491                    push_directive(tokens, "b0");
492                }
493                Dsel::B1 => {
494                    push_directive(tokens, "b1");
495                }
496                Dsel::B2 => {
497                    push_directive(tokens, "b2");
498                }
499                Dsel::B3 => {
500                    push_directive(tokens, "b3");
501                }
502                Dsel::H0 => {
503                    push_directive(tokens, "h0");
504                }
505                Dsel::H1 => {
506                    push_directive(tokens, "h1");
507                }
508            }
509            tokens.push(PtxToken::Comma);
510            if spaced {
511                tokens.push(PtxToken::Space);
512            }
513            self.a.unparse_tokens_mode(tokens, spaced);
514            if let Some(asel_8) = self.asel.as_ref() {
515                match asel_8 {
516                    Asel::B0 => {
517                        push_directive(tokens, "b0");
518                    }
519                    Asel::B1 => {
520                        push_directive(tokens, "b1");
521                    }
522                    Asel::B2 => {
523                        push_directive(tokens, "b2");
524                    }
525                    Asel::B3 => {
526                        push_directive(tokens, "b3");
527                    }
528                    Asel::H0 => {
529                        push_directive(tokens, "h0");
530                    }
531                    Asel::H1 => {
532                        push_directive(tokens, "h1");
533                    }
534                }
535            }
536            tokens.push(PtxToken::Comma);
537            if spaced {
538                tokens.push(PtxToken::Space);
539            }
540            self.b.unparse_tokens_mode(tokens, spaced);
541            if let Some(bsel_9) = self.bsel.as_ref() {
542                match bsel_9 {
543                    Bsel::B0 => {
544                        push_directive(tokens, "b0");
545                    }
546                    Bsel::B1 => {
547                        push_directive(tokens, "b1");
548                    }
549                    Bsel::B2 => {
550                        push_directive(tokens, "b2");
551                    }
552                    Bsel::B3 => {
553                        push_directive(tokens, "b3");
554                    }
555                    Bsel::H0 => {
556                        push_directive(tokens, "h0");
557                    }
558                    Bsel::H1 => {
559                        push_directive(tokens, "h1");
560                    }
561                }
562            }
563            tokens.push(PtxToken::Comma);
564            if spaced {
565                tokens.push(PtxToken::Space);
566            }
567            self.c.unparse_tokens_mode(tokens, spaced);
568            tokens.push(PtxToken::Semicolon);
569            if spaced {
570                tokens.push(PtxToken::Newline);
571            }
572        }
573    }
574
575    impl PtxUnparser for VshrDtypeAtypeU32SatMode1 {
576        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
577            self.unparse_tokens_mode(tokens, false);
578        }
579        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
580            push_opcode(tokens, "vshr");
581            match &self.dtype {
582                Dtype::U32 => {
583                    push_directive(tokens, "u32");
584                }
585                Dtype::S32 => {
586                    push_directive(tokens, "s32");
587                }
588            }
589            match &self.atype {
590                Atype::U32 => {
591                    push_directive(tokens, "u32");
592                }
593                Atype::S32 => {
594                    push_directive(tokens, "s32");
595                }
596            }
597            push_directive(tokens, "u32");
598            if self.sat {
599                push_directive(tokens, "sat");
600            }
601            match &self.mode {
602                Mode::Clamp => {
603                    push_directive(tokens, "clamp");
604                }
605                Mode::Wrap => {
606                    push_directive(tokens, "wrap");
607                }
608            }
609            if spaced {
610                tokens.push(PtxToken::Space);
611            }
612            self.d.unparse_tokens_mode(tokens, spaced);
613            match &self.dsel {
614                Dsel::B0 => {
615                    push_directive(tokens, "b0");
616                }
617                Dsel::B1 => {
618                    push_directive(tokens, "b1");
619                }
620                Dsel::B2 => {
621                    push_directive(tokens, "b2");
622                }
623                Dsel::B3 => {
624                    push_directive(tokens, "b3");
625                }
626                Dsel::H0 => {
627                    push_directive(tokens, "h0");
628                }
629                Dsel::H1 => {
630                    push_directive(tokens, "h1");
631                }
632            }
633            tokens.push(PtxToken::Comma);
634            if spaced {
635                tokens.push(PtxToken::Space);
636            }
637            self.a.unparse_tokens_mode(tokens, spaced);
638            if let Some(asel_10) = self.asel.as_ref() {
639                match asel_10 {
640                    Asel::B0 => {
641                        push_directive(tokens, "b0");
642                    }
643                    Asel::B1 => {
644                        push_directive(tokens, "b1");
645                    }
646                    Asel::B2 => {
647                        push_directive(tokens, "b2");
648                    }
649                    Asel::B3 => {
650                        push_directive(tokens, "b3");
651                    }
652                    Asel::H0 => {
653                        push_directive(tokens, "h0");
654                    }
655                    Asel::H1 => {
656                        push_directive(tokens, "h1");
657                    }
658                }
659            }
660            tokens.push(PtxToken::Comma);
661            if spaced {
662                tokens.push(PtxToken::Space);
663            }
664            self.b.unparse_tokens_mode(tokens, spaced);
665            if let Some(bsel_11) = self.bsel.as_ref() {
666                match bsel_11 {
667                    Bsel::B0 => {
668                        push_directive(tokens, "b0");
669                    }
670                    Bsel::B1 => {
671                        push_directive(tokens, "b1");
672                    }
673                    Bsel::B2 => {
674                        push_directive(tokens, "b2");
675                    }
676                    Bsel::B3 => {
677                        push_directive(tokens, "b3");
678                    }
679                    Bsel::H0 => {
680                        push_directive(tokens, "h0");
681                    }
682                    Bsel::H1 => {
683                        push_directive(tokens, "h1");
684                    }
685                }
686            }
687            tokens.push(PtxToken::Comma);
688            if spaced {
689                tokens.push(PtxToken::Space);
690            }
691            self.c.unparse_tokens_mode(tokens, spaced);
692            tokens.push(PtxToken::Semicolon);
693            if spaced {
694                tokens.push(PtxToken::Newline);
695            }
696        }
697    }
698}
ptx_parser/unparser/instruction/vsh.rs

ptx_parser/unparser/instruction/
vsh.rs
