ptx_parser/unparser/instruction/tex.rs
1//! Original PTX specification:
2//!
3//! tex.geom.v4.dtype.ctype d{|p}, [a, c] {, e} {, f};
4//! tex.geom.v4.dtype.ctype d{|p}, [a, b, c] {, e} {, f}; // explicit sampler
5//! tex.geom.v2.f16x2.ctype d{|p}, [a, c] {, e} {, f};
6//! tex.geom.v2.f16x2.ctype d{|p}, [a, b, c] {, e} {, f}; // explicit sampler
7//! // mipmaps
8//! tex.base.geom.v4.dtype.ctype d{|p}, [a, {b,} c] {, e} {, f};
9//! tex.level.geom.v4.dtype.ctype d{|p}, [a, {b,} c], lod {, e} {, f};
10//! tex.grad.geom.v4.dtype.ctype d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
11//! tex.base.geom.v2.f16x2.ctype d{|p}, [a, {b,} c] {, e} {, f};
12//! tex.level.geom.v2.f16x2.ctype d{|p}, [a, {b,} c], lod {, e} {, f};
13//! tex.grad.geom.v2.f16x2.ctype d{|p}, [a, {b,} c], dPdx, dPdy {, e} {, f};
14//! .geom = { .1d, .2d, .3d, .a1d, .a2d, .cube, .acube, .2dms, .a2dms };
15//! .dtype = { .u32, .s32, .f16, .f32 };
16//! .ctype = { .s32, .f32 }; // .cube, .acube require .f32
17//! // .2dms, .a2dms require .s32
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::tex::section_0::*;
27
28 impl PtxUnparser for TexGeomV4DtypeCtype {
29 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
30 push_opcode(tokens, "tex");
31 match &self.geom {
32 Geom::Acube => {
33 push_directive(tokens, "acube");
34 }
35 Geom::A2dms => {
36 push_directive(tokens, "a2dms");
37 }
38 Geom::Cube => {
39 push_directive(tokens, "cube");
40 }
41 Geom::_2dms => {
42 push_directive(tokens, "2dms");
43 }
44 Geom::A1d => {
45 push_directive(tokens, "a1d");
46 }
47 Geom::A2d => {
48 push_directive(tokens, "a2d");
49 }
50 Geom::_1d => {
51 push_directive(tokens, "1d");
52 }
53 Geom::_2d => {
54 push_directive(tokens, "2d");
55 }
56 Geom::_3d => {
57 push_directive(tokens, "3d");
58 }
59 }
60 push_directive(tokens, "v4");
61 match &self.dtype {
62 Dtype::U32 => {
63 push_directive(tokens, "u32");
64 }
65 Dtype::S32 => {
66 push_directive(tokens, "s32");
67 }
68 Dtype::F16 => {
69 push_directive(tokens, "f16");
70 }
71 Dtype::F32 => {
72 push_directive(tokens, "f32");
73 }
74 }
75 match &self.ctype {
76 Ctype::S32 => {
77 push_directive(tokens, "s32");
78 }
79 Ctype::F32 => {
80 push_directive(tokens, "f32");
81 }
82 }
83 self.d.unparse_tokens(tokens);
84 if let Some(p_0) = self.p.as_ref() {
85 tokens.push(PtxToken::Pipe);
86 p_0.unparse_tokens(tokens);
87 }
88 tokens.push(PtxToken::Comma);
89 self.a.unparse_tokens(tokens);
90 if self.e.is_some() { tokens.push(PtxToken::Comma); }
91 if let Some(opt_1) = self.e.as_ref() {
92 opt_1.unparse_tokens(tokens);
93 }
94 if self.f.is_some() { tokens.push(PtxToken::Comma); }
95 if let Some(opt_2) = self.f.as_ref() {
96 opt_2.unparse_tokens(tokens);
97 }
98 tokens.push(PtxToken::Semicolon);
99 }
100 }
101
102 impl PtxUnparser for TexGeomV4DtypeCtype1 {
103 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
104 push_opcode(tokens, "tex");
105 match &self.geom {
106 Geom::Acube => {
107 push_directive(tokens, "acube");
108 }
109 Geom::A2dms => {
110 push_directive(tokens, "a2dms");
111 }
112 Geom::Cube => {
113 push_directive(tokens, "cube");
114 }
115 Geom::_2dms => {
116 push_directive(tokens, "2dms");
117 }
118 Geom::A1d => {
119 push_directive(tokens, "a1d");
120 }
121 Geom::A2d => {
122 push_directive(tokens, "a2d");
123 }
124 Geom::_1d => {
125 push_directive(tokens, "1d");
126 }
127 Geom::_2d => {
128 push_directive(tokens, "2d");
129 }
130 Geom::_3d => {
131 push_directive(tokens, "3d");
132 }
133 }
134 push_directive(tokens, "v4");
135 match &self.dtype {
136 Dtype::U32 => {
137 push_directive(tokens, "u32");
138 }
139 Dtype::S32 => {
140 push_directive(tokens, "s32");
141 }
142 Dtype::F16 => {
143 push_directive(tokens, "f16");
144 }
145 Dtype::F32 => {
146 push_directive(tokens, "f32");
147 }
148 }
149 match &self.ctype {
150 Ctype::S32 => {
151 push_directive(tokens, "s32");
152 }
153 Ctype::F32 => {
154 push_directive(tokens, "f32");
155 }
156 }
157 self.d.unparse_tokens(tokens);
158 if let Some(p_3) = self.p.as_ref() {
159 tokens.push(PtxToken::Pipe);
160 p_3.unparse_tokens(tokens);
161 }
162 tokens.push(PtxToken::Comma);
163 self.a.unparse_tokens(tokens);
164 if self.e.is_some() { tokens.push(PtxToken::Comma); }
165 if let Some(opt_4) = self.e.as_ref() {
166 opt_4.unparse_tokens(tokens);
167 }
168 if self.f.is_some() { tokens.push(PtxToken::Comma); }
169 if let Some(opt_5) = self.f.as_ref() {
170 opt_5.unparse_tokens(tokens);
171 }
172 tokens.push(PtxToken::Semicolon);
173 }
174 }
175
176 impl PtxUnparser for TexGeomV2F16x2Ctype {
177 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
178 push_opcode(tokens, "tex");
179 match &self.geom {
180 Geom::Acube => {
181 push_directive(tokens, "acube");
182 }
183 Geom::A2dms => {
184 push_directive(tokens, "a2dms");
185 }
186 Geom::Cube => {
187 push_directive(tokens, "cube");
188 }
189 Geom::_2dms => {
190 push_directive(tokens, "2dms");
191 }
192 Geom::A1d => {
193 push_directive(tokens, "a1d");
194 }
195 Geom::A2d => {
196 push_directive(tokens, "a2d");
197 }
198 Geom::_1d => {
199 push_directive(tokens, "1d");
200 }
201 Geom::_2d => {
202 push_directive(tokens, "2d");
203 }
204 Geom::_3d => {
205 push_directive(tokens, "3d");
206 }
207 }
208 push_directive(tokens, "v2");
209 push_directive(tokens, "f16x2");
210 match &self.ctype {
211 Ctype::S32 => {
212 push_directive(tokens, "s32");
213 }
214 Ctype::F32 => {
215 push_directive(tokens, "f32");
216 }
217 }
218 self.d.unparse_tokens(tokens);
219 if let Some(p_6) = self.p.as_ref() {
220 tokens.push(PtxToken::Pipe);
221 p_6.unparse_tokens(tokens);
222 }
223 tokens.push(PtxToken::Comma);
224 self.a.unparse_tokens(tokens);
225 if self.e.is_some() { tokens.push(PtxToken::Comma); }
226 if let Some(opt_7) = self.e.as_ref() {
227 opt_7.unparse_tokens(tokens);
228 }
229 if self.f.is_some() { tokens.push(PtxToken::Comma); }
230 if let Some(opt_8) = self.f.as_ref() {
231 opt_8.unparse_tokens(tokens);
232 }
233 tokens.push(PtxToken::Semicolon);
234 }
235 }
236
237 impl PtxUnparser for TexGeomV2F16x2Ctype1 {
238 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
239 push_opcode(tokens, "tex");
240 match &self.geom {
241 Geom::Acube => {
242 push_directive(tokens, "acube");
243 }
244 Geom::A2dms => {
245 push_directive(tokens, "a2dms");
246 }
247 Geom::Cube => {
248 push_directive(tokens, "cube");
249 }
250 Geom::_2dms => {
251 push_directive(tokens, "2dms");
252 }
253 Geom::A1d => {
254 push_directive(tokens, "a1d");
255 }
256 Geom::A2d => {
257 push_directive(tokens, "a2d");
258 }
259 Geom::_1d => {
260 push_directive(tokens, "1d");
261 }
262 Geom::_2d => {
263 push_directive(tokens, "2d");
264 }
265 Geom::_3d => {
266 push_directive(tokens, "3d");
267 }
268 }
269 push_directive(tokens, "v2");
270 push_directive(tokens, "f16x2");
271 match &self.ctype {
272 Ctype::S32 => {
273 push_directive(tokens, "s32");
274 }
275 Ctype::F32 => {
276 push_directive(tokens, "f32");
277 }
278 }
279 self.d.unparse_tokens(tokens);
280 if let Some(p_9) = self.p.as_ref() {
281 tokens.push(PtxToken::Pipe);
282 p_9.unparse_tokens(tokens);
283 }
284 tokens.push(PtxToken::Comma);
285 self.a.unparse_tokens(tokens);
286 if self.e.is_some() { tokens.push(PtxToken::Comma); }
287 if let Some(opt_10) = self.e.as_ref() {
288 opt_10.unparse_tokens(tokens);
289 }
290 if self.f.is_some() { tokens.push(PtxToken::Comma); }
291 if let Some(opt_11) = self.f.as_ref() {
292 opt_11.unparse_tokens(tokens);
293 }
294 tokens.push(PtxToken::Semicolon);
295 }
296 }
297
298 impl PtxUnparser for TexBaseGeomV4DtypeCtype {
299 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
300 push_opcode(tokens, "tex");
301 push_directive(tokens, "base");
302 match &self.geom {
303 Geom::Acube => {
304 push_directive(tokens, "acube");
305 }
306 Geom::A2dms => {
307 push_directive(tokens, "a2dms");
308 }
309 Geom::Cube => {
310 push_directive(tokens, "cube");
311 }
312 Geom::_2dms => {
313 push_directive(tokens, "2dms");
314 }
315 Geom::A1d => {
316 push_directive(tokens, "a1d");
317 }
318 Geom::A2d => {
319 push_directive(tokens, "a2d");
320 }
321 Geom::_1d => {
322 push_directive(tokens, "1d");
323 }
324 Geom::_2d => {
325 push_directive(tokens, "2d");
326 }
327 Geom::_3d => {
328 push_directive(tokens, "3d");
329 }
330 }
331 push_directive(tokens, "v4");
332 match &self.dtype {
333 Dtype::U32 => {
334 push_directive(tokens, "u32");
335 }
336 Dtype::S32 => {
337 push_directive(tokens, "s32");
338 }
339 Dtype::F16 => {
340 push_directive(tokens, "f16");
341 }
342 Dtype::F32 => {
343 push_directive(tokens, "f32");
344 }
345 }
346 match &self.ctype {
347 Ctype::S32 => {
348 push_directive(tokens, "s32");
349 }
350 Ctype::F32 => {
351 push_directive(tokens, "f32");
352 }
353 }
354 self.d.unparse_tokens(tokens);
355 if let Some(p_12) = self.p.as_ref() {
356 tokens.push(PtxToken::Pipe);
357 p_12.unparse_tokens(tokens);
358 }
359 tokens.push(PtxToken::Comma);
360 self.a.unparse_tokens(tokens);
361 if self.e.is_some() { tokens.push(PtxToken::Comma); }
362 if let Some(opt_13) = self.e.as_ref() {
363 opt_13.unparse_tokens(tokens);
364 }
365 if self.f.is_some() { tokens.push(PtxToken::Comma); }
366 if let Some(opt_14) = self.f.as_ref() {
367 opt_14.unparse_tokens(tokens);
368 }
369 tokens.push(PtxToken::Semicolon);
370 }
371 }
372
373 impl PtxUnparser for TexLevelGeomV4DtypeCtype {
374 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
375 push_opcode(tokens, "tex");
376 push_directive(tokens, "level");
377 match &self.geom {
378 Geom::Acube => {
379 push_directive(tokens, "acube");
380 }
381 Geom::A2dms => {
382 push_directive(tokens, "a2dms");
383 }
384 Geom::Cube => {
385 push_directive(tokens, "cube");
386 }
387 Geom::_2dms => {
388 push_directive(tokens, "2dms");
389 }
390 Geom::A1d => {
391 push_directive(tokens, "a1d");
392 }
393 Geom::A2d => {
394 push_directive(tokens, "a2d");
395 }
396 Geom::_1d => {
397 push_directive(tokens, "1d");
398 }
399 Geom::_2d => {
400 push_directive(tokens, "2d");
401 }
402 Geom::_3d => {
403 push_directive(tokens, "3d");
404 }
405 }
406 push_directive(tokens, "v4");
407 match &self.dtype {
408 Dtype::U32 => {
409 push_directive(tokens, "u32");
410 }
411 Dtype::S32 => {
412 push_directive(tokens, "s32");
413 }
414 Dtype::F16 => {
415 push_directive(tokens, "f16");
416 }
417 Dtype::F32 => {
418 push_directive(tokens, "f32");
419 }
420 }
421 match &self.ctype {
422 Ctype::S32 => {
423 push_directive(tokens, "s32");
424 }
425 Ctype::F32 => {
426 push_directive(tokens, "f32");
427 }
428 }
429 self.d.unparse_tokens(tokens);
430 if let Some(p_15) = self.p.as_ref() {
431 tokens.push(PtxToken::Pipe);
432 p_15.unparse_tokens(tokens);
433 }
434 tokens.push(PtxToken::Comma);
435 self.a.unparse_tokens(tokens);
436 tokens.push(PtxToken::Comma);
437 self.lod.unparse_tokens(tokens);
438 if self.e.is_some() { tokens.push(PtxToken::Comma); }
439 if let Some(opt_16) = self.e.as_ref() {
440 opt_16.unparse_tokens(tokens);
441 }
442 if self.f.is_some() { tokens.push(PtxToken::Comma); }
443 if let Some(opt_17) = self.f.as_ref() {
444 opt_17.unparse_tokens(tokens);
445 }
446 tokens.push(PtxToken::Semicolon);
447 }
448 }
449
450 impl PtxUnparser for TexGradGeomV4DtypeCtype {
451 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
452 push_opcode(tokens, "tex");
453 push_directive(tokens, "grad");
454 match &self.geom {
455 Geom::Acube => {
456 push_directive(tokens, "acube");
457 }
458 Geom::A2dms => {
459 push_directive(tokens, "a2dms");
460 }
461 Geom::Cube => {
462 push_directive(tokens, "cube");
463 }
464 Geom::_2dms => {
465 push_directive(tokens, "2dms");
466 }
467 Geom::A1d => {
468 push_directive(tokens, "a1d");
469 }
470 Geom::A2d => {
471 push_directive(tokens, "a2d");
472 }
473 Geom::_1d => {
474 push_directive(tokens, "1d");
475 }
476 Geom::_2d => {
477 push_directive(tokens, "2d");
478 }
479 Geom::_3d => {
480 push_directive(tokens, "3d");
481 }
482 }
483 push_directive(tokens, "v4");
484 match &self.dtype {
485 Dtype::U32 => {
486 push_directive(tokens, "u32");
487 }
488 Dtype::S32 => {
489 push_directive(tokens, "s32");
490 }
491 Dtype::F16 => {
492 push_directive(tokens, "f16");
493 }
494 Dtype::F32 => {
495 push_directive(tokens, "f32");
496 }
497 }
498 match &self.ctype {
499 Ctype::S32 => {
500 push_directive(tokens, "s32");
501 }
502 Ctype::F32 => {
503 push_directive(tokens, "f32");
504 }
505 }
506 self.d.unparse_tokens(tokens);
507 if let Some(p_18) = self.p.as_ref() {
508 tokens.push(PtxToken::Pipe);
509 p_18.unparse_tokens(tokens);
510 }
511 tokens.push(PtxToken::Comma);
512 self.a.unparse_tokens(tokens);
513 tokens.push(PtxToken::Comma);
514 self.dpdx.unparse_tokens(tokens);
515 tokens.push(PtxToken::Comma);
516 self.dpdy.unparse_tokens(tokens);
517 if self.e.is_some() { tokens.push(PtxToken::Comma); }
518 if let Some(opt_19) = self.e.as_ref() {
519 opt_19.unparse_tokens(tokens);
520 }
521 if self.f.is_some() { tokens.push(PtxToken::Comma); }
522 if let Some(opt_20) = self.f.as_ref() {
523 opt_20.unparse_tokens(tokens);
524 }
525 tokens.push(PtxToken::Semicolon);
526 }
527 }
528
529 impl PtxUnparser for TexBaseGeomV2F16x2Ctype {
530 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
531 push_opcode(tokens, "tex");
532 push_directive(tokens, "base");
533 match &self.geom {
534 Geom::Acube => {
535 push_directive(tokens, "acube");
536 }
537 Geom::A2dms => {
538 push_directive(tokens, "a2dms");
539 }
540 Geom::Cube => {
541 push_directive(tokens, "cube");
542 }
543 Geom::_2dms => {
544 push_directive(tokens, "2dms");
545 }
546 Geom::A1d => {
547 push_directive(tokens, "a1d");
548 }
549 Geom::A2d => {
550 push_directive(tokens, "a2d");
551 }
552 Geom::_1d => {
553 push_directive(tokens, "1d");
554 }
555 Geom::_2d => {
556 push_directive(tokens, "2d");
557 }
558 Geom::_3d => {
559 push_directive(tokens, "3d");
560 }
561 }
562 push_directive(tokens, "v2");
563 push_directive(tokens, "f16x2");
564 match &self.ctype {
565 Ctype::S32 => {
566 push_directive(tokens, "s32");
567 }
568 Ctype::F32 => {
569 push_directive(tokens, "f32");
570 }
571 }
572 self.d.unparse_tokens(tokens);
573 if let Some(p_21) = self.p.as_ref() {
574 tokens.push(PtxToken::Pipe);
575 p_21.unparse_tokens(tokens);
576 }
577 tokens.push(PtxToken::Comma);
578 self.a.unparse_tokens(tokens);
579 if self.e.is_some() { tokens.push(PtxToken::Comma); }
580 if let Some(opt_22) = self.e.as_ref() {
581 opt_22.unparse_tokens(tokens);
582 }
583 if self.f.is_some() { tokens.push(PtxToken::Comma); }
584 if let Some(opt_23) = self.f.as_ref() {
585 opt_23.unparse_tokens(tokens);
586 }
587 tokens.push(PtxToken::Semicolon);
588 }
589 }
590
591 impl PtxUnparser for TexLevelGeomV2F16x2Ctype {
592 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
593 push_opcode(tokens, "tex");
594 push_directive(tokens, "level");
595 match &self.geom {
596 Geom::Acube => {
597 push_directive(tokens, "acube");
598 }
599 Geom::A2dms => {
600 push_directive(tokens, "a2dms");
601 }
602 Geom::Cube => {
603 push_directive(tokens, "cube");
604 }
605 Geom::_2dms => {
606 push_directive(tokens, "2dms");
607 }
608 Geom::A1d => {
609 push_directive(tokens, "a1d");
610 }
611 Geom::A2d => {
612 push_directive(tokens, "a2d");
613 }
614 Geom::_1d => {
615 push_directive(tokens, "1d");
616 }
617 Geom::_2d => {
618 push_directive(tokens, "2d");
619 }
620 Geom::_3d => {
621 push_directive(tokens, "3d");
622 }
623 }
624 push_directive(tokens, "v2");
625 push_directive(tokens, "f16x2");
626 match &self.ctype {
627 Ctype::S32 => {
628 push_directive(tokens, "s32");
629 }
630 Ctype::F32 => {
631 push_directive(tokens, "f32");
632 }
633 }
634 self.d.unparse_tokens(tokens);
635 if let Some(p_24) = self.p.as_ref() {
636 tokens.push(PtxToken::Pipe);
637 p_24.unparse_tokens(tokens);
638 }
639 tokens.push(PtxToken::Comma);
640 self.a.unparse_tokens(tokens);
641 tokens.push(PtxToken::Comma);
642 self.lod.unparse_tokens(tokens);
643 if self.e.is_some() { tokens.push(PtxToken::Comma); }
644 if let Some(opt_25) = self.e.as_ref() {
645 opt_25.unparse_tokens(tokens);
646 }
647 if self.f.is_some() { tokens.push(PtxToken::Comma); }
648 if let Some(opt_26) = self.f.as_ref() {
649 opt_26.unparse_tokens(tokens);
650 }
651 tokens.push(PtxToken::Semicolon);
652 }
653 }
654
655 impl PtxUnparser for TexGradGeomV2F16x2Ctype {
656 fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
657 push_opcode(tokens, "tex");
658 push_directive(tokens, "grad");
659 match &self.geom {
660 Geom::Acube => {
661 push_directive(tokens, "acube");
662 }
663 Geom::A2dms => {
664 push_directive(tokens, "a2dms");
665 }
666 Geom::Cube => {
667 push_directive(tokens, "cube");
668 }
669 Geom::_2dms => {
670 push_directive(tokens, "2dms");
671 }
672 Geom::A1d => {
673 push_directive(tokens, "a1d");
674 }
675 Geom::A2d => {
676 push_directive(tokens, "a2d");
677 }
678 Geom::_1d => {
679 push_directive(tokens, "1d");
680 }
681 Geom::_2d => {
682 push_directive(tokens, "2d");
683 }
684 Geom::_3d => {
685 push_directive(tokens, "3d");
686 }
687 }
688 push_directive(tokens, "v2");
689 push_directive(tokens, "f16x2");
690 match &self.ctype {
691 Ctype::S32 => {
692 push_directive(tokens, "s32");
693 }
694 Ctype::F32 => {
695 push_directive(tokens, "f32");
696 }
697 }
698 self.d.unparse_tokens(tokens);
699 if let Some(p_27) = self.p.as_ref() {
700 tokens.push(PtxToken::Pipe);
701 p_27.unparse_tokens(tokens);
702 }
703 tokens.push(PtxToken::Comma);
704 self.a.unparse_tokens(tokens);
705 tokens.push(PtxToken::Comma);
706 self.dpdx.unparse_tokens(tokens);
707 tokens.push(PtxToken::Comma);
708 self.dpdy.unparse_tokens(tokens);
709 if self.e.is_some() { tokens.push(PtxToken::Comma); }
710 if let Some(opt_28) = self.e.as_ref() {
711 opt_28.unparse_tokens(tokens);
712 }
713 if self.f.is_some() { tokens.push(PtxToken::Comma); }
714 if let Some(opt_29) = self.f.as_ref() {
715 opt_29.unparse_tokens(tokens);
716 }
717 tokens.push(PtxToken::Semicolon);
718 }
719 }
720
721}
722