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

ptx_parser/unparser/instruction/
tex.rs
