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