ptx_parser/parser/instruction/
cvt.rs

1//! Original PTX specification:
2//!
3//! cvt{.irnd}{.ftz}{.sat}.dtype.atype         d, a;  // integer rounding
4//! cvt{.frnd}{.ftz}{.sat}.dtype.atype         d, a;  // fp rounding
5//! cvt.frnd2{.relu}{.satfinite}.f16.f32       d, a;
6//! cvt.frnd2{.relu}{.satfinite}.f16x2.f32     d, a, b;
7//! cvt.rs{.relu}{.satfinite}.f16x2.f32        d, a, b, rbits;
8//! cvt.frnd2{.relu}{.satfinite}.bf16.f32      d, a;
9//! cvt.frnd2{.relu}{.satfinite}.bf16x2.f32    d, a, b;
10//! cvt.rs{.relu}{.satfinite}.bf16x2.f32       d, a, b, rbits;
11//! cvt.rna{.satfinite}.tf32.f32               d, a;
12//! cvt.frnd2{.satfinite}{.relu}.tf32.f32      d, a;
13//! cvt.rn.satfinite{.relu}.f8x2type.f32       d, a, b;
14//! cvt.rn.satfinite{.relu}.f8x2type.f16x2     d, a;
15//! cvt.rn{.relu}.f16x2.f8x2type              d, a;
16//! cvt.rs{.relu}.satfinite.f8x4type.f32       d, {a, b, e, f}, rbits;
17//! cvt.rn.satfinite{.relu}.f4x2type.f32       d, a, b;
18//! cvt.rn{.relu}.f16x2.f4x2type               d, a;
19//! cvt.rs{.relu}.satfinite.f4x4type.f32       d, {a, b, e, f}, rbits;
20//! cvt.rn.satfinite{.relu}.f6x2type.f32       d, a, b;
21//! cvt.rn{.relu}.f16x2.f6x2type               d, a;
22//! cvt.rs{.relu}.satfinite.f6x4type.f32       d, {a, b, e, f}, rbits;
23//! cvt.frnd3{.satfinite}.ue8m0x2.f32          d, a, b;
24//! cvt.frnd3{.satfinite}.ue8m0x2.bf16x2       d, a;
25//! cvt.rn.bf16x2.ue8m0x2                      d, a;
26//! .irnd   = { .rni, .rzi, .rmi, .rpi };
27//! .frnd   = { .rn,  .rz,  .rm,  .rp  };
28//! .frnd2  = { .rn,  .rz };
29//! .frnd3  = { .rz,  .rp };
30//! .dtype = .atype = { .u8,   .u16, .u32, .u64,
31//! .s8,   .s16, .s32, .s64,
32//! .bf16, .f16, .f32, .f64 };
33//! .f8x2type = { .e4m3x2, .e5m2x2 };
34//! .f4x2type = { .e2m1x2 };
35//! .f6x2type = { .e2m3x2, .e3m2x2 };
36//! .f4x4type = { .e2m1x4 };
37//! .f8x4type = { .e4m3x4, .e5m2x4 };
38//! .f6x4type = { .e2m3x4, .e3m2x4 };
39
40#![allow(unused)]
41
42use crate::lexer::PtxToken;
43use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
44use crate::r#type::common::*;
45
46pub mod section_0 {
47    use super::*;
48    use crate::r#type::instruction::cvt::section_0::*;
49
50    // ============================================================================
51    // Generated enum parsers
52    // ============================================================================
53
54    impl PtxParser for Atype {
55        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
56            // Try Bf16
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".bf16").is_ok() {
60                    return Ok(Atype::Bf16);
61                }
62                stream.set_position(saved_pos);
63            }
64            let saved_pos = stream.position();
65            // Try U16
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".u16").is_ok() {
69                    return Ok(Atype::U16);
70                }
71                stream.set_position(saved_pos);
72            }
73            stream.set_position(saved_pos);
74            let saved_pos = stream.position();
75            // Try U32
76            {
77                let saved_pos = stream.position();
78                if stream.expect_string(".u32").is_ok() {
79                    return Ok(Atype::U32);
80                }
81                stream.set_position(saved_pos);
82            }
83            stream.set_position(saved_pos);
84            let saved_pos = stream.position();
85            // Try U64
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".u64").is_ok() {
89                    return Ok(Atype::U64);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let saved_pos = stream.position();
95            // Try S16
96            {
97                let saved_pos = stream.position();
98                if stream.expect_string(".s16").is_ok() {
99                    return Ok(Atype::S16);
100                }
101                stream.set_position(saved_pos);
102            }
103            stream.set_position(saved_pos);
104            let saved_pos = stream.position();
105            // Try S32
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".s32").is_ok() {
109                    return Ok(Atype::S32);
110                }
111                stream.set_position(saved_pos);
112            }
113            stream.set_position(saved_pos);
114            let saved_pos = stream.position();
115            // Try S64
116            {
117                let saved_pos = stream.position();
118                if stream.expect_string(".s64").is_ok() {
119                    return Ok(Atype::S64);
120                }
121                stream.set_position(saved_pos);
122            }
123            stream.set_position(saved_pos);
124            let saved_pos = stream.position();
125            // Try F16
126            {
127                let saved_pos = stream.position();
128                if stream.expect_string(".f16").is_ok() {
129                    return Ok(Atype::F16);
130                }
131                stream.set_position(saved_pos);
132            }
133            stream.set_position(saved_pos);
134            let saved_pos = stream.position();
135            // Try F32
136            {
137                let saved_pos = stream.position();
138                if stream.expect_string(".f32").is_ok() {
139                    return Ok(Atype::F32);
140                }
141                stream.set_position(saved_pos);
142            }
143            stream.set_position(saved_pos);
144            let saved_pos = stream.position();
145            // Try F64
146            {
147                let saved_pos = stream.position();
148                if stream.expect_string(".f64").is_ok() {
149                    return Ok(Atype::F64);
150                }
151                stream.set_position(saved_pos);
152            }
153            stream.set_position(saved_pos);
154            let saved_pos = stream.position();
155            // Try U8
156            {
157                let saved_pos = stream.position();
158                if stream.expect_string(".u8").is_ok() {
159                    return Ok(Atype::U8);
160                }
161                stream.set_position(saved_pos);
162            }
163            stream.set_position(saved_pos);
164            let saved_pos = stream.position();
165            // Try S8
166            {
167                let saved_pos = stream.position();
168                if stream.expect_string(".s8").is_ok() {
169                    return Ok(Atype::S8);
170                }
171                stream.set_position(saved_pos);
172            }
173            stream.set_position(saved_pos);
174            let span = stream
175                .peek()
176                .map(|(_, s)| s.clone())
177                .unwrap_or(Span { start: 0, end: 0 });
178            let expected = &[
179                ".bf16", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f16", ".f32", ".f64",
180                ".u8", ".s8",
181            ];
182            let found = stream
183                .peek()
184                .map(|(t, _)| format!("{:?}", t))
185                .unwrap_or_else(|_| "<end of input>".to_string());
186            Err(crate::parser::unexpected_value(span, expected, found))
187        }
188    }
189
190    impl PtxParser for Dtype {
191        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
192            // Try Bf16
193            {
194                let saved_pos = stream.position();
195                if stream.expect_string(".bf16").is_ok() {
196                    return Ok(Dtype::Bf16);
197                }
198                stream.set_position(saved_pos);
199            }
200            let saved_pos = stream.position();
201            // Try U16
202            {
203                let saved_pos = stream.position();
204                if stream.expect_string(".u16").is_ok() {
205                    return Ok(Dtype::U16);
206                }
207                stream.set_position(saved_pos);
208            }
209            stream.set_position(saved_pos);
210            let saved_pos = stream.position();
211            // Try U32
212            {
213                let saved_pos = stream.position();
214                if stream.expect_string(".u32").is_ok() {
215                    return Ok(Dtype::U32);
216                }
217                stream.set_position(saved_pos);
218            }
219            stream.set_position(saved_pos);
220            let saved_pos = stream.position();
221            // Try U64
222            {
223                let saved_pos = stream.position();
224                if stream.expect_string(".u64").is_ok() {
225                    return Ok(Dtype::U64);
226                }
227                stream.set_position(saved_pos);
228            }
229            stream.set_position(saved_pos);
230            let saved_pos = stream.position();
231            // Try S16
232            {
233                let saved_pos = stream.position();
234                if stream.expect_string(".s16").is_ok() {
235                    return Ok(Dtype::S16);
236                }
237                stream.set_position(saved_pos);
238            }
239            stream.set_position(saved_pos);
240            let saved_pos = stream.position();
241            // Try S32
242            {
243                let saved_pos = stream.position();
244                if stream.expect_string(".s32").is_ok() {
245                    return Ok(Dtype::S32);
246                }
247                stream.set_position(saved_pos);
248            }
249            stream.set_position(saved_pos);
250            let saved_pos = stream.position();
251            // Try S64
252            {
253                let saved_pos = stream.position();
254                if stream.expect_string(".s64").is_ok() {
255                    return Ok(Dtype::S64);
256                }
257                stream.set_position(saved_pos);
258            }
259            stream.set_position(saved_pos);
260            let saved_pos = stream.position();
261            // Try F16
262            {
263                let saved_pos = stream.position();
264                if stream.expect_string(".f16").is_ok() {
265                    return Ok(Dtype::F16);
266                }
267                stream.set_position(saved_pos);
268            }
269            stream.set_position(saved_pos);
270            let saved_pos = stream.position();
271            // Try F32
272            {
273                let saved_pos = stream.position();
274                if stream.expect_string(".f32").is_ok() {
275                    return Ok(Dtype::F32);
276                }
277                stream.set_position(saved_pos);
278            }
279            stream.set_position(saved_pos);
280            let saved_pos = stream.position();
281            // Try F64
282            {
283                let saved_pos = stream.position();
284                if stream.expect_string(".f64").is_ok() {
285                    return Ok(Dtype::F64);
286                }
287                stream.set_position(saved_pos);
288            }
289            stream.set_position(saved_pos);
290            let saved_pos = stream.position();
291            // Try U8
292            {
293                let saved_pos = stream.position();
294                if stream.expect_string(".u8").is_ok() {
295                    return Ok(Dtype::U8);
296                }
297                stream.set_position(saved_pos);
298            }
299            stream.set_position(saved_pos);
300            let saved_pos = stream.position();
301            // Try S8
302            {
303                let saved_pos = stream.position();
304                if stream.expect_string(".s8").is_ok() {
305                    return Ok(Dtype::S8);
306                }
307                stream.set_position(saved_pos);
308            }
309            stream.set_position(saved_pos);
310            let span = stream
311                .peek()
312                .map(|(_, s)| s.clone())
313                .unwrap_or(Span { start: 0, end: 0 });
314            let expected = &[
315                ".bf16", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f16", ".f32", ".f64",
316                ".u8", ".s8",
317            ];
318            let found = stream
319                .peek()
320                .map(|(t, _)| format!("{:?}", t))
321                .unwrap_or_else(|_| "<end of input>".to_string());
322            Err(crate::parser::unexpected_value(span, expected, found))
323        }
324    }
325
326    impl PtxParser for F4x2type {
327        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
328            // Try E2m1x2
329            {
330                let saved_pos = stream.position();
331                if stream.expect_string(".e2m1x2").is_ok() {
332                    return Ok(F4x2type::E2m1x2);
333                }
334                stream.set_position(saved_pos);
335            }
336            let span = stream
337                .peek()
338                .map(|(_, s)| s.clone())
339                .unwrap_or(Span { start: 0, end: 0 });
340            let expected = &[".e2m1x2"];
341            let found = stream
342                .peek()
343                .map(|(t, _)| format!("{:?}", t))
344                .unwrap_or_else(|_| "<end of input>".to_string());
345            Err(crate::parser::unexpected_value(span, expected, found))
346        }
347    }
348
349    impl PtxParser for F4x4type {
350        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
351            // Try E2m1x4
352            {
353                let saved_pos = stream.position();
354                if stream.expect_string(".e2m1x4").is_ok() {
355                    return Ok(F4x4type::E2m1x4);
356                }
357                stream.set_position(saved_pos);
358            }
359            let span = stream
360                .peek()
361                .map(|(_, s)| s.clone())
362                .unwrap_or(Span { start: 0, end: 0 });
363            let expected = &[".e2m1x4"];
364            let found = stream
365                .peek()
366                .map(|(t, _)| format!("{:?}", t))
367                .unwrap_or_else(|_| "<end of input>".to_string());
368            Err(crate::parser::unexpected_value(span, expected, found))
369        }
370    }
371
372    impl PtxParser for F6x2type {
373        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
374            // Try E2m3x2
375            {
376                let saved_pos = stream.position();
377                if stream.expect_string(".e2m3x2").is_ok() {
378                    return Ok(F6x2type::E2m3x2);
379                }
380                stream.set_position(saved_pos);
381            }
382            let saved_pos = stream.position();
383            // Try E3m2x2
384            {
385                let saved_pos = stream.position();
386                if stream.expect_string(".e3m2x2").is_ok() {
387                    return Ok(F6x2type::E3m2x2);
388                }
389                stream.set_position(saved_pos);
390            }
391            stream.set_position(saved_pos);
392            let span = stream
393                .peek()
394                .map(|(_, s)| s.clone())
395                .unwrap_or(Span { start: 0, end: 0 });
396            let expected = &[".e2m3x2", ".e3m2x2"];
397            let found = stream
398                .peek()
399                .map(|(t, _)| format!("{:?}", t))
400                .unwrap_or_else(|_| "<end of input>".to_string());
401            Err(crate::parser::unexpected_value(span, expected, found))
402        }
403    }
404
405    impl PtxParser for F6x4type {
406        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
407            // Try E2m3x4
408            {
409                let saved_pos = stream.position();
410                if stream.expect_string(".e2m3x4").is_ok() {
411                    return Ok(F6x4type::E2m3x4);
412                }
413                stream.set_position(saved_pos);
414            }
415            let saved_pos = stream.position();
416            // Try E3m2x4
417            {
418                let saved_pos = stream.position();
419                if stream.expect_string(".e3m2x4").is_ok() {
420                    return Ok(F6x4type::E3m2x4);
421                }
422                stream.set_position(saved_pos);
423            }
424            stream.set_position(saved_pos);
425            let span = stream
426                .peek()
427                .map(|(_, s)| s.clone())
428                .unwrap_or(Span { start: 0, end: 0 });
429            let expected = &[".e2m3x4", ".e3m2x4"];
430            let found = stream
431                .peek()
432                .map(|(t, _)| format!("{:?}", t))
433                .unwrap_or_else(|_| "<end of input>".to_string());
434            Err(crate::parser::unexpected_value(span, expected, found))
435        }
436    }
437
438    impl PtxParser for F8x2type {
439        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
440            // Try E4m3x2
441            {
442                let saved_pos = stream.position();
443                if stream.expect_string(".e4m3x2").is_ok() {
444                    return Ok(F8x2type::E4m3x2);
445                }
446                stream.set_position(saved_pos);
447            }
448            let saved_pos = stream.position();
449            // Try E5m2x2
450            {
451                let saved_pos = stream.position();
452                if stream.expect_string(".e5m2x2").is_ok() {
453                    return Ok(F8x2type::E5m2x2);
454                }
455                stream.set_position(saved_pos);
456            }
457            stream.set_position(saved_pos);
458            let span = stream
459                .peek()
460                .map(|(_, s)| s.clone())
461                .unwrap_or(Span { start: 0, end: 0 });
462            let expected = &[".e4m3x2", ".e5m2x2"];
463            let found = stream
464                .peek()
465                .map(|(t, _)| format!("{:?}", t))
466                .unwrap_or_else(|_| "<end of input>".to_string());
467            Err(crate::parser::unexpected_value(span, expected, found))
468        }
469    }
470
471    impl PtxParser for F8x4type {
472        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
473            // Try E4m3x4
474            {
475                let saved_pos = stream.position();
476                if stream.expect_string(".e4m3x4").is_ok() {
477                    return Ok(F8x4type::E4m3x4);
478                }
479                stream.set_position(saved_pos);
480            }
481            let saved_pos = stream.position();
482            // Try E5m2x4
483            {
484                let saved_pos = stream.position();
485                if stream.expect_string(".e5m2x4").is_ok() {
486                    return Ok(F8x4type::E5m2x4);
487                }
488                stream.set_position(saved_pos);
489            }
490            stream.set_position(saved_pos);
491            let span = stream
492                .peek()
493                .map(|(_, s)| s.clone())
494                .unwrap_or(Span { start: 0, end: 0 });
495            let expected = &[".e4m3x4", ".e5m2x4"];
496            let found = stream
497                .peek()
498                .map(|(t, _)| format!("{:?}", t))
499                .unwrap_or_else(|_| "<end of input>".to_string());
500            Err(crate::parser::unexpected_value(span, expected, found))
501        }
502    }
503
504    impl PtxParser for Frnd {
505        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
506            // Try Rn
507            {
508                let saved_pos = stream.position();
509                if stream.expect_string(".rn").is_ok() {
510                    return Ok(Frnd::Rn);
511                }
512                stream.set_position(saved_pos);
513            }
514            let saved_pos = stream.position();
515            // Try Rz
516            {
517                let saved_pos = stream.position();
518                if stream.expect_string(".rz").is_ok() {
519                    return Ok(Frnd::Rz);
520                }
521                stream.set_position(saved_pos);
522            }
523            stream.set_position(saved_pos);
524            let saved_pos = stream.position();
525            // Try Rm
526            {
527                let saved_pos = stream.position();
528                if stream.expect_string(".rm").is_ok() {
529                    return Ok(Frnd::Rm);
530                }
531                stream.set_position(saved_pos);
532            }
533            stream.set_position(saved_pos);
534            let saved_pos = stream.position();
535            // Try Rp
536            {
537                let saved_pos = stream.position();
538                if stream.expect_string(".rp").is_ok() {
539                    return Ok(Frnd::Rp);
540                }
541                stream.set_position(saved_pos);
542            }
543            stream.set_position(saved_pos);
544            let span = stream
545                .peek()
546                .map(|(_, s)| s.clone())
547                .unwrap_or(Span { start: 0, end: 0 });
548            let expected = &[".rn", ".rz", ".rm", ".rp"];
549            let found = stream
550                .peek()
551                .map(|(t, _)| format!("{:?}", t))
552                .unwrap_or_else(|_| "<end of input>".to_string());
553            Err(crate::parser::unexpected_value(span, expected, found))
554        }
555    }
556
557    impl PtxParser for Frnd2 {
558        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
559            // Try Rn
560            {
561                let saved_pos = stream.position();
562                if stream.expect_string(".rn").is_ok() {
563                    return Ok(Frnd2::Rn);
564                }
565                stream.set_position(saved_pos);
566            }
567            let saved_pos = stream.position();
568            // Try Rz
569            {
570                let saved_pos = stream.position();
571                if stream.expect_string(".rz").is_ok() {
572                    return Ok(Frnd2::Rz);
573                }
574                stream.set_position(saved_pos);
575            }
576            stream.set_position(saved_pos);
577            let span = stream
578                .peek()
579                .map(|(_, s)| s.clone())
580                .unwrap_or(Span { start: 0, end: 0 });
581            let expected = &[".rn", ".rz"];
582            let found = stream
583                .peek()
584                .map(|(t, _)| format!("{:?}", t))
585                .unwrap_or_else(|_| "<end of input>".to_string());
586            Err(crate::parser::unexpected_value(span, expected, found))
587        }
588    }
589
590    impl PtxParser for Frnd3 {
591        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
592            // Try Rz
593            {
594                let saved_pos = stream.position();
595                if stream.expect_string(".rz").is_ok() {
596                    return Ok(Frnd3::Rz);
597                }
598                stream.set_position(saved_pos);
599            }
600            let saved_pos = stream.position();
601            // Try Rp
602            {
603                let saved_pos = stream.position();
604                if stream.expect_string(".rp").is_ok() {
605                    return Ok(Frnd3::Rp);
606                }
607                stream.set_position(saved_pos);
608            }
609            stream.set_position(saved_pos);
610            let span = stream
611                .peek()
612                .map(|(_, s)| s.clone())
613                .unwrap_or(Span { start: 0, end: 0 });
614            let expected = &[".rz", ".rp"];
615            let found = stream
616                .peek()
617                .map(|(t, _)| format!("{:?}", t))
618                .unwrap_or_else(|_| "<end of input>".to_string());
619            Err(crate::parser::unexpected_value(span, expected, found))
620        }
621    }
622
623    impl PtxParser for Irnd {
624        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
625            // Try Rni
626            {
627                let saved_pos = stream.position();
628                if stream.expect_string(".rni").is_ok() {
629                    return Ok(Irnd::Rni);
630                }
631                stream.set_position(saved_pos);
632            }
633            let saved_pos = stream.position();
634            // Try Rzi
635            {
636                let saved_pos = stream.position();
637                if stream.expect_string(".rzi").is_ok() {
638                    return Ok(Irnd::Rzi);
639                }
640                stream.set_position(saved_pos);
641            }
642            stream.set_position(saved_pos);
643            let saved_pos = stream.position();
644            // Try Rmi
645            {
646                let saved_pos = stream.position();
647                if stream.expect_string(".rmi").is_ok() {
648                    return Ok(Irnd::Rmi);
649                }
650                stream.set_position(saved_pos);
651            }
652            stream.set_position(saved_pos);
653            let saved_pos = stream.position();
654            // Try Rpi
655            {
656                let saved_pos = stream.position();
657                if stream.expect_string(".rpi").is_ok() {
658                    return Ok(Irnd::Rpi);
659                }
660                stream.set_position(saved_pos);
661            }
662            stream.set_position(saved_pos);
663            let span = stream
664                .peek()
665                .map(|(_, s)| s.clone())
666                .unwrap_or(Span { start: 0, end: 0 });
667            let expected = &[".rni", ".rzi", ".rmi", ".rpi"];
668            let found = stream
669                .peek()
670                .map(|(t, _)| format!("{:?}", t))
671                .unwrap_or_else(|_| "<end of input>".to_string());
672            Err(crate::parser::unexpected_value(span, expected, found))
673        }
674    }
675
676    impl PtxParser for CvtIrndFtzSatDtypeAtype {
677        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
678            stream.expect_string("cvt")?;
679            let saved_pos = stream.position();
680            let irnd = match Irnd::parse(stream) {
681                Ok(val) => Some(val),
682                Err(_) => {
683                    stream.set_position(saved_pos);
684                    None
685                }
686            };
687            stream.expect_complete()?;
688            let saved_pos = stream.position();
689            let ftz = stream.expect_string(".ftz").is_ok();
690            if !ftz {
691                stream.set_position(saved_pos);
692            }
693            stream.expect_complete()?;
694            let saved_pos = stream.position();
695            let sat = stream.expect_string(".sat").is_ok();
696            if !sat {
697                stream.set_position(saved_pos);
698            }
699            stream.expect_complete()?;
700            let dtype = Dtype::parse(stream)?;
701            stream.expect_complete()?;
702            let atype = Atype::parse(stream)?;
703            stream.expect_complete()?;
704            let d = GeneralOperand::parse(stream)?;
705            stream.expect_complete()?;
706            stream.expect(&PtxToken::Comma)?;
707            let a = GeneralOperand::parse(stream)?;
708            stream.expect_complete()?;
709            stream.expect_complete()?;
710            stream.expect(&PtxToken::Semicolon)?;
711            Ok(CvtIrndFtzSatDtypeAtype {
712                irnd,
713                ftz,
714                sat,
715                dtype,
716                atype,
717                d,
718                a,
719            })
720        }
721    }
722
723    impl PtxParser for CvtFrndFtzSatDtypeAtype {
724        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
725            stream.expect_string("cvt")?;
726            let saved_pos = stream.position();
727            let frnd = match Frnd::parse(stream) {
728                Ok(val) => Some(val),
729                Err(_) => {
730                    stream.set_position(saved_pos);
731                    None
732                }
733            };
734            stream.expect_complete()?;
735            let saved_pos = stream.position();
736            let ftz = stream.expect_string(".ftz").is_ok();
737            if !ftz {
738                stream.set_position(saved_pos);
739            }
740            stream.expect_complete()?;
741            let saved_pos = stream.position();
742            let sat = stream.expect_string(".sat").is_ok();
743            if !sat {
744                stream.set_position(saved_pos);
745            }
746            stream.expect_complete()?;
747            let dtype = Dtype::parse(stream)?;
748            stream.expect_complete()?;
749            let atype = Atype::parse(stream)?;
750            stream.expect_complete()?;
751            let d = GeneralOperand::parse(stream)?;
752            stream.expect_complete()?;
753            stream.expect(&PtxToken::Comma)?;
754            let a = GeneralOperand::parse(stream)?;
755            stream.expect_complete()?;
756            stream.expect_complete()?;
757            stream.expect(&PtxToken::Semicolon)?;
758            Ok(CvtFrndFtzSatDtypeAtype {
759                frnd,
760                ftz,
761                sat,
762                dtype,
763                atype,
764                d,
765                a,
766            })
767        }
768    }
769
770    impl PtxParser for CvtFrnd2ReluSatfiniteF16F32 {
771        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
772            stream.expect_string("cvt")?;
773            let frnd2 = Frnd2::parse(stream)?;
774            stream.expect_complete()?;
775            let saved_pos = stream.position();
776            let relu = stream.expect_string(".relu").is_ok();
777            if !relu {
778                stream.set_position(saved_pos);
779            }
780            stream.expect_complete()?;
781            let saved_pos = stream.position();
782            let satfinite = stream.expect_string(".satfinite").is_ok();
783            if !satfinite {
784                stream.set_position(saved_pos);
785            }
786            stream.expect_complete()?;
787            stream.expect_string(".f16")?;
788            let f16 = ();
789            stream.expect_complete()?;
790            stream.expect_string(".f32")?;
791            let f32 = ();
792            stream.expect_complete()?;
793            let d = GeneralOperand::parse(stream)?;
794            stream.expect_complete()?;
795            stream.expect(&PtxToken::Comma)?;
796            let a = GeneralOperand::parse(stream)?;
797            stream.expect_complete()?;
798            stream.expect_complete()?;
799            stream.expect(&PtxToken::Semicolon)?;
800            Ok(CvtFrnd2ReluSatfiniteF16F32 {
801                frnd2,
802                relu,
803                satfinite,
804                f16,
805                f32,
806                d,
807                a,
808            })
809        }
810    }
811
812    impl PtxParser for CvtFrnd2ReluSatfiniteF16x2F32 {
813        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
814            stream.expect_string("cvt")?;
815            let frnd2 = Frnd2::parse(stream)?;
816            stream.expect_complete()?;
817            let saved_pos = stream.position();
818            let relu = stream.expect_string(".relu").is_ok();
819            if !relu {
820                stream.set_position(saved_pos);
821            }
822            stream.expect_complete()?;
823            let saved_pos = stream.position();
824            let satfinite = stream.expect_string(".satfinite").is_ok();
825            if !satfinite {
826                stream.set_position(saved_pos);
827            }
828            stream.expect_complete()?;
829            stream.expect_string(".f16x2")?;
830            let f16x2 = ();
831            stream.expect_complete()?;
832            stream.expect_string(".f32")?;
833            let f32 = ();
834            stream.expect_complete()?;
835            let d = GeneralOperand::parse(stream)?;
836            stream.expect_complete()?;
837            stream.expect(&PtxToken::Comma)?;
838            let a = GeneralOperand::parse(stream)?;
839            stream.expect_complete()?;
840            stream.expect(&PtxToken::Comma)?;
841            let b = GeneralOperand::parse(stream)?;
842            stream.expect_complete()?;
843            stream.expect_complete()?;
844            stream.expect(&PtxToken::Semicolon)?;
845            Ok(CvtFrnd2ReluSatfiniteF16x2F32 {
846                frnd2,
847                relu,
848                satfinite,
849                f16x2,
850                f32,
851                d,
852                a,
853                b,
854            })
855        }
856    }
857
858    impl PtxParser for CvtRsReluSatfiniteF16x2F32 {
859        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
860            stream.expect_string("cvt")?;
861            stream.expect_string(".rs")?;
862            let rs = ();
863            stream.expect_complete()?;
864            let saved_pos = stream.position();
865            let relu = stream.expect_string(".relu").is_ok();
866            if !relu {
867                stream.set_position(saved_pos);
868            }
869            stream.expect_complete()?;
870            let saved_pos = stream.position();
871            let satfinite = stream.expect_string(".satfinite").is_ok();
872            if !satfinite {
873                stream.set_position(saved_pos);
874            }
875            stream.expect_complete()?;
876            stream.expect_string(".f16x2")?;
877            let f16x2 = ();
878            stream.expect_complete()?;
879            stream.expect_string(".f32")?;
880            let f32 = ();
881            stream.expect_complete()?;
882            let d = GeneralOperand::parse(stream)?;
883            stream.expect_complete()?;
884            stream.expect(&PtxToken::Comma)?;
885            let a = GeneralOperand::parse(stream)?;
886            stream.expect_complete()?;
887            stream.expect(&PtxToken::Comma)?;
888            let b = GeneralOperand::parse(stream)?;
889            stream.expect_complete()?;
890            stream.expect(&PtxToken::Comma)?;
891            let rbits = GeneralOperand::parse(stream)?;
892            stream.expect_complete()?;
893            stream.expect_complete()?;
894            stream.expect(&PtxToken::Semicolon)?;
895            Ok(CvtRsReluSatfiniteF16x2F32 {
896                rs,
897                relu,
898                satfinite,
899                f16x2,
900                f32,
901                d,
902                a,
903                b,
904                rbits,
905            })
906        }
907    }
908
909    impl PtxParser for CvtFrnd2ReluSatfiniteBf16F32 {
910        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
911            stream.expect_string("cvt")?;
912            let frnd2 = Frnd2::parse(stream)?;
913            stream.expect_complete()?;
914            let saved_pos = stream.position();
915            let relu = stream.expect_string(".relu").is_ok();
916            if !relu {
917                stream.set_position(saved_pos);
918            }
919            stream.expect_complete()?;
920            let saved_pos = stream.position();
921            let satfinite = stream.expect_string(".satfinite").is_ok();
922            if !satfinite {
923                stream.set_position(saved_pos);
924            }
925            stream.expect_complete()?;
926            stream.expect_string(".bf16")?;
927            let bf16 = ();
928            stream.expect_complete()?;
929            stream.expect_string(".f32")?;
930            let f32 = ();
931            stream.expect_complete()?;
932            let d = GeneralOperand::parse(stream)?;
933            stream.expect_complete()?;
934            stream.expect(&PtxToken::Comma)?;
935            let a = GeneralOperand::parse(stream)?;
936            stream.expect_complete()?;
937            stream.expect_complete()?;
938            stream.expect(&PtxToken::Semicolon)?;
939            Ok(CvtFrnd2ReluSatfiniteBf16F32 {
940                frnd2,
941                relu,
942                satfinite,
943                bf16,
944                f32,
945                d,
946                a,
947            })
948        }
949    }
950
951    impl PtxParser for CvtFrnd2ReluSatfiniteBf16x2F32 {
952        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
953            stream.expect_string("cvt")?;
954            let frnd2 = Frnd2::parse(stream)?;
955            stream.expect_complete()?;
956            let saved_pos = stream.position();
957            let relu = stream.expect_string(".relu").is_ok();
958            if !relu {
959                stream.set_position(saved_pos);
960            }
961            stream.expect_complete()?;
962            let saved_pos = stream.position();
963            let satfinite = stream.expect_string(".satfinite").is_ok();
964            if !satfinite {
965                stream.set_position(saved_pos);
966            }
967            stream.expect_complete()?;
968            stream.expect_string(".bf16x2")?;
969            let bf16x2 = ();
970            stream.expect_complete()?;
971            stream.expect_string(".f32")?;
972            let f32 = ();
973            stream.expect_complete()?;
974            let d = GeneralOperand::parse(stream)?;
975            stream.expect_complete()?;
976            stream.expect(&PtxToken::Comma)?;
977            let a = GeneralOperand::parse(stream)?;
978            stream.expect_complete()?;
979            stream.expect(&PtxToken::Comma)?;
980            let b = GeneralOperand::parse(stream)?;
981            stream.expect_complete()?;
982            stream.expect_complete()?;
983            stream.expect(&PtxToken::Semicolon)?;
984            Ok(CvtFrnd2ReluSatfiniteBf16x2F32 {
985                frnd2,
986                relu,
987                satfinite,
988                bf16x2,
989                f32,
990                d,
991                a,
992                b,
993            })
994        }
995    }
996
997    impl PtxParser for CvtRsReluSatfiniteBf16x2F32 {
998        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
999            stream.expect_string("cvt")?;
1000            stream.expect_string(".rs")?;
1001            let rs = ();
1002            stream.expect_complete()?;
1003            let saved_pos = stream.position();
1004            let relu = stream.expect_string(".relu").is_ok();
1005            if !relu {
1006                stream.set_position(saved_pos);
1007            }
1008            stream.expect_complete()?;
1009            let saved_pos = stream.position();
1010            let satfinite = stream.expect_string(".satfinite").is_ok();
1011            if !satfinite {
1012                stream.set_position(saved_pos);
1013            }
1014            stream.expect_complete()?;
1015            stream.expect_string(".bf16x2")?;
1016            let bf16x2 = ();
1017            stream.expect_complete()?;
1018            stream.expect_string(".f32")?;
1019            let f32 = ();
1020            stream.expect_complete()?;
1021            let d = GeneralOperand::parse(stream)?;
1022            stream.expect_complete()?;
1023            stream.expect(&PtxToken::Comma)?;
1024            let a = GeneralOperand::parse(stream)?;
1025            stream.expect_complete()?;
1026            stream.expect(&PtxToken::Comma)?;
1027            let b = GeneralOperand::parse(stream)?;
1028            stream.expect_complete()?;
1029            stream.expect(&PtxToken::Comma)?;
1030            let rbits = GeneralOperand::parse(stream)?;
1031            stream.expect_complete()?;
1032            stream.expect_complete()?;
1033            stream.expect(&PtxToken::Semicolon)?;
1034            Ok(CvtRsReluSatfiniteBf16x2F32 {
1035                rs,
1036                relu,
1037                satfinite,
1038                bf16x2,
1039                f32,
1040                d,
1041                a,
1042                b,
1043                rbits,
1044            })
1045        }
1046    }
1047
1048    impl PtxParser for CvtRnaSatfiniteTf32F32 {
1049        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1050            stream.expect_string("cvt")?;
1051            stream.expect_string(".rna")?;
1052            let rna = ();
1053            stream.expect_complete()?;
1054            let saved_pos = stream.position();
1055            let satfinite = stream.expect_string(".satfinite").is_ok();
1056            if !satfinite {
1057                stream.set_position(saved_pos);
1058            }
1059            stream.expect_complete()?;
1060            stream.expect_string(".tf32")?;
1061            let tf32 = ();
1062            stream.expect_complete()?;
1063            stream.expect_string(".f32")?;
1064            let f32 = ();
1065            stream.expect_complete()?;
1066            let d = GeneralOperand::parse(stream)?;
1067            stream.expect_complete()?;
1068            stream.expect(&PtxToken::Comma)?;
1069            let a = GeneralOperand::parse(stream)?;
1070            stream.expect_complete()?;
1071            stream.expect_complete()?;
1072            stream.expect(&PtxToken::Semicolon)?;
1073            Ok(CvtRnaSatfiniteTf32F32 {
1074                rna,
1075                satfinite,
1076                tf32,
1077                f32,
1078                d,
1079                a,
1080            })
1081        }
1082    }
1083
1084    impl PtxParser for CvtFrnd2SatfiniteReluTf32F32 {
1085        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1086            stream.expect_string("cvt")?;
1087            let frnd2 = Frnd2::parse(stream)?;
1088            stream.expect_complete()?;
1089            let saved_pos = stream.position();
1090            let satfinite = stream.expect_string(".satfinite").is_ok();
1091            if !satfinite {
1092                stream.set_position(saved_pos);
1093            }
1094            stream.expect_complete()?;
1095            let saved_pos = stream.position();
1096            let relu = stream.expect_string(".relu").is_ok();
1097            if !relu {
1098                stream.set_position(saved_pos);
1099            }
1100            stream.expect_complete()?;
1101            stream.expect_string(".tf32")?;
1102            let tf32 = ();
1103            stream.expect_complete()?;
1104            stream.expect_string(".f32")?;
1105            let f32 = ();
1106            stream.expect_complete()?;
1107            let d = GeneralOperand::parse(stream)?;
1108            stream.expect_complete()?;
1109            stream.expect(&PtxToken::Comma)?;
1110            let a = GeneralOperand::parse(stream)?;
1111            stream.expect_complete()?;
1112            stream.expect_complete()?;
1113            stream.expect(&PtxToken::Semicolon)?;
1114            Ok(CvtFrnd2SatfiniteReluTf32F32 {
1115                frnd2,
1116                satfinite,
1117                relu,
1118                tf32,
1119                f32,
1120                d,
1121                a,
1122            })
1123        }
1124    }
1125
1126    impl PtxParser for CvtRnSatfiniteReluF8x2typeF32 {
1127        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1128            stream.expect_string("cvt")?;
1129            stream.expect_string(".rn")?;
1130            let rn = ();
1131            stream.expect_complete()?;
1132            stream.expect_string(".satfinite")?;
1133            let satfinite = ();
1134            stream.expect_complete()?;
1135            let saved_pos = stream.position();
1136            let relu = stream.expect_string(".relu").is_ok();
1137            if !relu {
1138                stream.set_position(saved_pos);
1139            }
1140            stream.expect_complete()?;
1141            let f8x2type = F8x2type::parse(stream)?;
1142            stream.expect_complete()?;
1143            stream.expect_string(".f32")?;
1144            let f32 = ();
1145            stream.expect_complete()?;
1146            let d = GeneralOperand::parse(stream)?;
1147            stream.expect_complete()?;
1148            stream.expect(&PtxToken::Comma)?;
1149            let a = GeneralOperand::parse(stream)?;
1150            stream.expect_complete()?;
1151            stream.expect(&PtxToken::Comma)?;
1152            let b = GeneralOperand::parse(stream)?;
1153            stream.expect_complete()?;
1154            stream.expect_complete()?;
1155            stream.expect(&PtxToken::Semicolon)?;
1156            Ok(CvtRnSatfiniteReluF8x2typeF32 {
1157                rn,
1158                satfinite,
1159                relu,
1160                f8x2type,
1161                f32,
1162                d,
1163                a,
1164                b,
1165            })
1166        }
1167    }
1168
1169    impl PtxParser for CvtRnSatfiniteReluF8x2typeF16x2 {
1170        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1171            stream.expect_string("cvt")?;
1172            stream.expect_string(".rn")?;
1173            let rn = ();
1174            stream.expect_complete()?;
1175            stream.expect_string(".satfinite")?;
1176            let satfinite = ();
1177            stream.expect_complete()?;
1178            let saved_pos = stream.position();
1179            let relu = stream.expect_string(".relu").is_ok();
1180            if !relu {
1181                stream.set_position(saved_pos);
1182            }
1183            stream.expect_complete()?;
1184            let f8x2type = F8x2type::parse(stream)?;
1185            stream.expect_complete()?;
1186            stream.expect_string(".f16x2")?;
1187            let f16x2 = ();
1188            stream.expect_complete()?;
1189            let d = GeneralOperand::parse(stream)?;
1190            stream.expect_complete()?;
1191            stream.expect(&PtxToken::Comma)?;
1192            let a = GeneralOperand::parse(stream)?;
1193            stream.expect_complete()?;
1194            stream.expect_complete()?;
1195            stream.expect(&PtxToken::Semicolon)?;
1196            Ok(CvtRnSatfiniteReluF8x2typeF16x2 {
1197                rn,
1198                satfinite,
1199                relu,
1200                f8x2type,
1201                f16x2,
1202                d,
1203                a,
1204            })
1205        }
1206    }
1207
1208    impl PtxParser for CvtRnReluF16x2F8x2type {
1209        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1210            stream.expect_string("cvt")?;
1211            stream.expect_string(".rn")?;
1212            let rn = ();
1213            stream.expect_complete()?;
1214            let saved_pos = stream.position();
1215            let relu = stream.expect_string(".relu").is_ok();
1216            if !relu {
1217                stream.set_position(saved_pos);
1218            }
1219            stream.expect_complete()?;
1220            stream.expect_string(".f16x2")?;
1221            let f16x2 = ();
1222            stream.expect_complete()?;
1223            let f8x2type = F8x2type::parse(stream)?;
1224            stream.expect_complete()?;
1225            let d = GeneralOperand::parse(stream)?;
1226            stream.expect_complete()?;
1227            stream.expect(&PtxToken::Comma)?;
1228            let a = GeneralOperand::parse(stream)?;
1229            stream.expect_complete()?;
1230            stream.expect_complete()?;
1231            stream.expect(&PtxToken::Semicolon)?;
1232            Ok(CvtRnReluF16x2F8x2type {
1233                rn,
1234                relu,
1235                f16x2,
1236                f8x2type,
1237                d,
1238                a,
1239            })
1240        }
1241    }
1242
1243    impl PtxParser for CvtRsReluSatfiniteF8x4typeF32 {
1244        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1245            stream.expect_string("cvt")?;
1246            stream.expect_string(".rs")?;
1247            let rs = ();
1248            stream.expect_complete()?;
1249            let saved_pos = stream.position();
1250            let relu = stream.expect_string(".relu").is_ok();
1251            if !relu {
1252                stream.set_position(saved_pos);
1253            }
1254            stream.expect_complete()?;
1255            stream.expect_string(".satfinite")?;
1256            let satfinite = ();
1257            stream.expect_complete()?;
1258            let f8x4type = F8x4type::parse(stream)?;
1259            stream.expect_complete()?;
1260            stream.expect_string(".f32")?;
1261            let f32 = ();
1262            stream.expect_complete()?;
1263            let d = GeneralOperand::parse(stream)?;
1264            stream.expect_complete()?;
1265            stream.expect(&PtxToken::Comma)?;
1266            let a = VectorOperand::parse(stream)?;
1267            stream.expect_complete()?;
1268            stream.expect(&PtxToken::Comma)?;
1269            let rbits = GeneralOperand::parse(stream)?;
1270            stream.expect_complete()?;
1271            stream.expect_complete()?;
1272            stream.expect(&PtxToken::Semicolon)?;
1273            Ok(CvtRsReluSatfiniteF8x4typeF32 {
1274                rs,
1275                relu,
1276                satfinite,
1277                f8x4type,
1278                f32,
1279                d,
1280                a,
1281                rbits,
1282            })
1283        }
1284    }
1285
1286    impl PtxParser for CvtRnSatfiniteReluF4x2typeF32 {
1287        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1288            stream.expect_string("cvt")?;
1289            stream.expect_string(".rn")?;
1290            let rn = ();
1291            stream.expect_complete()?;
1292            stream.expect_string(".satfinite")?;
1293            let satfinite = ();
1294            stream.expect_complete()?;
1295            let saved_pos = stream.position();
1296            let relu = stream.expect_string(".relu").is_ok();
1297            if !relu {
1298                stream.set_position(saved_pos);
1299            }
1300            stream.expect_complete()?;
1301            let f4x2type = F4x2type::parse(stream)?;
1302            stream.expect_complete()?;
1303            stream.expect_string(".f32")?;
1304            let f32 = ();
1305            stream.expect_complete()?;
1306            let d = GeneralOperand::parse(stream)?;
1307            stream.expect_complete()?;
1308            stream.expect(&PtxToken::Comma)?;
1309            let a = GeneralOperand::parse(stream)?;
1310            stream.expect_complete()?;
1311            stream.expect(&PtxToken::Comma)?;
1312            let b = GeneralOperand::parse(stream)?;
1313            stream.expect_complete()?;
1314            stream.expect_complete()?;
1315            stream.expect(&PtxToken::Semicolon)?;
1316            Ok(CvtRnSatfiniteReluF4x2typeF32 {
1317                rn,
1318                satfinite,
1319                relu,
1320                f4x2type,
1321                f32,
1322                d,
1323                a,
1324                b,
1325            })
1326        }
1327    }
1328
1329    impl PtxParser for CvtRnReluF16x2F4x2type {
1330        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1331            stream.expect_string("cvt")?;
1332            stream.expect_string(".rn")?;
1333            let rn = ();
1334            stream.expect_complete()?;
1335            let saved_pos = stream.position();
1336            let relu = stream.expect_string(".relu").is_ok();
1337            if !relu {
1338                stream.set_position(saved_pos);
1339            }
1340            stream.expect_complete()?;
1341            stream.expect_string(".f16x2")?;
1342            let f16x2 = ();
1343            stream.expect_complete()?;
1344            let f4x2type = F4x2type::parse(stream)?;
1345            stream.expect_complete()?;
1346            let d = GeneralOperand::parse(stream)?;
1347            stream.expect_complete()?;
1348            stream.expect(&PtxToken::Comma)?;
1349            let a = GeneralOperand::parse(stream)?;
1350            stream.expect_complete()?;
1351            stream.expect_complete()?;
1352            stream.expect(&PtxToken::Semicolon)?;
1353            Ok(CvtRnReluF16x2F4x2type {
1354                rn,
1355                relu,
1356                f16x2,
1357                f4x2type,
1358                d,
1359                a,
1360            })
1361        }
1362    }
1363
1364    impl PtxParser for CvtRsReluSatfiniteF4x4typeF32 {
1365        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1366            stream.expect_string("cvt")?;
1367            stream.expect_string(".rs")?;
1368            let rs = ();
1369            stream.expect_complete()?;
1370            let saved_pos = stream.position();
1371            let relu = stream.expect_string(".relu").is_ok();
1372            if !relu {
1373                stream.set_position(saved_pos);
1374            }
1375            stream.expect_complete()?;
1376            stream.expect_string(".satfinite")?;
1377            let satfinite = ();
1378            stream.expect_complete()?;
1379            let f4x4type = F4x4type::parse(stream)?;
1380            stream.expect_complete()?;
1381            stream.expect_string(".f32")?;
1382            let f32 = ();
1383            stream.expect_complete()?;
1384            let d = GeneralOperand::parse(stream)?;
1385            stream.expect_complete()?;
1386            stream.expect(&PtxToken::Comma)?;
1387            let a = VectorOperand::parse(stream)?;
1388            stream.expect_complete()?;
1389            stream.expect(&PtxToken::Comma)?;
1390            let rbits = GeneralOperand::parse(stream)?;
1391            stream.expect_complete()?;
1392            stream.expect_complete()?;
1393            stream.expect(&PtxToken::Semicolon)?;
1394            Ok(CvtRsReluSatfiniteF4x4typeF32 {
1395                rs,
1396                relu,
1397                satfinite,
1398                f4x4type,
1399                f32,
1400                d,
1401                a,
1402                rbits,
1403            })
1404        }
1405    }
1406
1407    impl PtxParser for CvtRnSatfiniteReluF6x2typeF32 {
1408        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1409            stream.expect_string("cvt")?;
1410            stream.expect_string(".rn")?;
1411            let rn = ();
1412            stream.expect_complete()?;
1413            stream.expect_string(".satfinite")?;
1414            let satfinite = ();
1415            stream.expect_complete()?;
1416            let saved_pos = stream.position();
1417            let relu = stream.expect_string(".relu").is_ok();
1418            if !relu {
1419                stream.set_position(saved_pos);
1420            }
1421            stream.expect_complete()?;
1422            let f6x2type = F6x2type::parse(stream)?;
1423            stream.expect_complete()?;
1424            stream.expect_string(".f32")?;
1425            let f32 = ();
1426            stream.expect_complete()?;
1427            let d = GeneralOperand::parse(stream)?;
1428            stream.expect_complete()?;
1429            stream.expect(&PtxToken::Comma)?;
1430            let a = GeneralOperand::parse(stream)?;
1431            stream.expect_complete()?;
1432            stream.expect(&PtxToken::Comma)?;
1433            let b = GeneralOperand::parse(stream)?;
1434            stream.expect_complete()?;
1435            stream.expect_complete()?;
1436            stream.expect(&PtxToken::Semicolon)?;
1437            Ok(CvtRnSatfiniteReluF6x2typeF32 {
1438                rn,
1439                satfinite,
1440                relu,
1441                f6x2type,
1442                f32,
1443                d,
1444                a,
1445                b,
1446            })
1447        }
1448    }
1449
1450    impl PtxParser for CvtRnReluF16x2F6x2type {
1451        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1452            stream.expect_string("cvt")?;
1453            stream.expect_string(".rn")?;
1454            let rn = ();
1455            stream.expect_complete()?;
1456            let saved_pos = stream.position();
1457            let relu = stream.expect_string(".relu").is_ok();
1458            if !relu {
1459                stream.set_position(saved_pos);
1460            }
1461            stream.expect_complete()?;
1462            stream.expect_string(".f16x2")?;
1463            let f16x2 = ();
1464            stream.expect_complete()?;
1465            let f6x2type = F6x2type::parse(stream)?;
1466            stream.expect_complete()?;
1467            let d = GeneralOperand::parse(stream)?;
1468            stream.expect_complete()?;
1469            stream.expect(&PtxToken::Comma)?;
1470            let a = GeneralOperand::parse(stream)?;
1471            stream.expect_complete()?;
1472            stream.expect_complete()?;
1473            stream.expect(&PtxToken::Semicolon)?;
1474            Ok(CvtRnReluF16x2F6x2type {
1475                rn,
1476                relu,
1477                f16x2,
1478                f6x2type,
1479                d,
1480                a,
1481            })
1482        }
1483    }
1484
1485    impl PtxParser for CvtRsReluSatfiniteF6x4typeF32 {
1486        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1487            stream.expect_string("cvt")?;
1488            stream.expect_string(".rs")?;
1489            let rs = ();
1490            stream.expect_complete()?;
1491            let saved_pos = stream.position();
1492            let relu = stream.expect_string(".relu").is_ok();
1493            if !relu {
1494                stream.set_position(saved_pos);
1495            }
1496            stream.expect_complete()?;
1497            stream.expect_string(".satfinite")?;
1498            let satfinite = ();
1499            stream.expect_complete()?;
1500            let f6x4type = F6x4type::parse(stream)?;
1501            stream.expect_complete()?;
1502            stream.expect_string(".f32")?;
1503            let f32 = ();
1504            stream.expect_complete()?;
1505            let d = GeneralOperand::parse(stream)?;
1506            stream.expect_complete()?;
1507            stream.expect(&PtxToken::Comma)?;
1508            let a = VectorOperand::parse(stream)?;
1509            stream.expect_complete()?;
1510            stream.expect(&PtxToken::Comma)?;
1511            let rbits = GeneralOperand::parse(stream)?;
1512            stream.expect_complete()?;
1513            stream.expect_complete()?;
1514            stream.expect(&PtxToken::Semicolon)?;
1515            Ok(CvtRsReluSatfiniteF6x4typeF32 {
1516                rs,
1517                relu,
1518                satfinite,
1519                f6x4type,
1520                f32,
1521                d,
1522                a,
1523                rbits,
1524            })
1525        }
1526    }
1527
1528    impl PtxParser for CvtFrnd3SatfiniteUe8m0x2F32 {
1529        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1530            stream.expect_string("cvt")?;
1531            let frnd3 = Frnd3::parse(stream)?;
1532            stream.expect_complete()?;
1533            let saved_pos = stream.position();
1534            let satfinite = stream.expect_string(".satfinite").is_ok();
1535            if !satfinite {
1536                stream.set_position(saved_pos);
1537            }
1538            stream.expect_complete()?;
1539            stream.expect_string(".ue8m0x2")?;
1540            let ue8m0x2 = ();
1541            stream.expect_complete()?;
1542            stream.expect_string(".f32")?;
1543            let f32 = ();
1544            stream.expect_complete()?;
1545            let d = GeneralOperand::parse(stream)?;
1546            stream.expect_complete()?;
1547            stream.expect(&PtxToken::Comma)?;
1548            let a = GeneralOperand::parse(stream)?;
1549            stream.expect_complete()?;
1550            stream.expect(&PtxToken::Comma)?;
1551            let b = GeneralOperand::parse(stream)?;
1552            stream.expect_complete()?;
1553            stream.expect_complete()?;
1554            stream.expect(&PtxToken::Semicolon)?;
1555            Ok(CvtFrnd3SatfiniteUe8m0x2F32 {
1556                frnd3,
1557                satfinite,
1558                ue8m0x2,
1559                f32,
1560                d,
1561                a,
1562                b,
1563            })
1564        }
1565    }
1566
1567    impl PtxParser for CvtFrnd3SatfiniteUe8m0x2Bf16x2 {
1568        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1569            stream.expect_string("cvt")?;
1570            let frnd3 = Frnd3::parse(stream)?;
1571            stream.expect_complete()?;
1572            let saved_pos = stream.position();
1573            let satfinite = stream.expect_string(".satfinite").is_ok();
1574            if !satfinite {
1575                stream.set_position(saved_pos);
1576            }
1577            stream.expect_complete()?;
1578            stream.expect_string(".ue8m0x2")?;
1579            let ue8m0x2 = ();
1580            stream.expect_complete()?;
1581            stream.expect_string(".bf16x2")?;
1582            let bf16x2 = ();
1583            stream.expect_complete()?;
1584            let d = GeneralOperand::parse(stream)?;
1585            stream.expect_complete()?;
1586            stream.expect(&PtxToken::Comma)?;
1587            let a = GeneralOperand::parse(stream)?;
1588            stream.expect_complete()?;
1589            stream.expect_complete()?;
1590            stream.expect(&PtxToken::Semicolon)?;
1591            Ok(CvtFrnd3SatfiniteUe8m0x2Bf16x2 {
1592                frnd3,
1593                satfinite,
1594                ue8m0x2,
1595                bf16x2,
1596                d,
1597                a,
1598            })
1599        }
1600    }
1601
1602    impl PtxParser for CvtRnBf16x2Ue8m0x2 {
1603        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1604            stream.expect_string("cvt")?;
1605            stream.expect_string(".rn")?;
1606            let rn = ();
1607            stream.expect_complete()?;
1608            stream.expect_string(".bf16x2")?;
1609            let bf16x2 = ();
1610            stream.expect_complete()?;
1611            stream.expect_string(".ue8m0x2")?;
1612            let ue8m0x2 = ();
1613            stream.expect_complete()?;
1614            let d = GeneralOperand::parse(stream)?;
1615            stream.expect_complete()?;
1616            stream.expect(&PtxToken::Comma)?;
1617            let a = GeneralOperand::parse(stream)?;
1618            stream.expect_complete()?;
1619            stream.expect_complete()?;
1620            stream.expect(&PtxToken::Semicolon)?;
1621            Ok(CvtRnBf16x2Ue8m0x2 {
1622                rn,
1623                bf16x2,
1624                ue8m0x2,
1625                d,
1626                a,
1627            })
1628        }
1629    }
1630}
ptx_parser/parser/instruction/cvt.rs

ptx_parser/parser/instruction/
cvt.rs
