ptx_parser/parser/instruction/
mma_sp.rs

1//! Original PTX specification:
2//!
3//! // Half precision floating point type:
4//! mma.spvariant.sync.aligned.m16n8k16.row.col.dtype.f16.f16.ctype  d, a, b, c, e, f;
5//! mma.spvariant.sync.aligned.m16n8k32.row.col.dtype.f16.f16.ctype  d, a, b, c, e, f;
6//! .ctype     = {.f16, .f32};
7//! .dtype     = {.f16, .f32};
8//! .spvariant = {.sp, .sp::ordered_metadata};
9//! ----------------------------------------------------
10//! // Alternate floating point type:
11//! mma.spvariant.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32     d, a, b, c, e, f;
12//! mma.spvariant.sync.aligned.m16n8k32.row.col.f32.bf16.bf16.f32     d, a, b, c, e, f;
13//! mma.spvariant.sync.aligned.m16n8k8.row.col.f32.tf32.tf32.f32      d, a, b, c, e, f;
14//! mma.spvariant.sync.aligned.m16n8k16.row.col.f32.tf32.tf32.f32     d, a, b, c, e, f;
15//! mma.spvariant.sync.aligned.m16n8k64.row.col.f32.f8type.f8type.f32 d, a, b, c, e, f;
16//! mma.sp::ordered_metadata.sync.aligned.m16n8k64.row.col.kind.dtype.f8f6f4type.f8f6f4type.ctype d, a, b, c, e, f;
17//! .f8type     = {.e4m3, .e5m2};
18//! .spvariant  = {.sp, .sp::ordered_metadata};
19//! .f8f6f4type = {.e4m3, .e5m2, .e3m2, .e2m3, .e2m1};
20//! .kind       = {.kind::f8f6f4};
21//! .ctype      = {.f16, .f32};
22//! .dtype      = {.f16, .f32};
23//! ----------------------------------------------------
24//! // Alternate floating point type:
25//! // Alternate floating point type with block scaling:
26//! mma.spvariant.sync.aligned.m16n8k128.row.col.kind.block_scale{.scale_vec_size}.f32.e2m1.e2m1.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
27//! .spvariant      = {.sp::ordered_metadata};
28//! .kind           = {.kind::mxf4};
29//! .scale_vec_size = {.scale_vec::2X};
30//! .stype          = {.ue8m0};
31//! ----------------------------------------------------
32//! // Alternate floating point type:
33//! mma.spvariant.sync.aligned.m16n8k128.row.col.kind.block_scale.scale_vec_size.f32.e2m1.e2m1.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
34//! .spvariant      = {.sp::ordered_metadata};
35//! .kind           = {.kind::mxf4nvf4};
36//! .scale_vec_size = {.scale_vec::2X, .scale_vec::4X};
37//! .stype          = {.ue8m0, .ue4m3};
38//! ----------------------------------------------------
39//! // Alternate floating point type:
40//! mma.spvariant.sync.aligned.m16n8k64.row.col.kind.block_scale{.scale_vec_size}.f32.f8f6f4type.f8f6f4type.f32.stype d, a, b, c, e, f, scale-a-data, {byte-id-a, thread-id-a}, scale-b-data, {byte-id-b, thread-id-b};
41//! .spvariant      = {.sp::ordered_metadata};
42//! .kind           = {.kind::mxf8f6f4};
43//! .scale_vec_size = {.scale_vec::1X};
44//! .f8f6f4type     = {.e4m3, .e5m2, .e3m2, .e2m3, .e2m1};
45//! .stype          = {.ue8m0};
46//! ----------------------------------------------------
47//! // Alternate floating point type:
48//! // Integer type:
49//! mma.spvariant.sync.aligned.shape.row.col{.satfinite}.s32.atype.btype.s32 d, a, b, c, e, f;
50//! .shape     = {.m16n8k32, .m16n8k64};
51//! .atype     = {.u8, .s8};
52//! .btype     = {.u8, .s8};
53//! .spvariant = {.sp, .sp::ordered_metadata};
54//! ----------------------------------------------------
55//! // Alternate floating point type:
56//! mma.spvariant.sync.aligned.shape.row.col{.satfinite}.s32.atype.btype.s32 d, a, b, c, e, f;
57//! .shape     = {.m16n8k64, .m16n8k128};
58//! .atype     = {.u4, .s4};
59//! .btype     = {.u4, .s4};
60//! .spvariant = {.sp, .sp::ordered_metadata};
61
62#![allow(unused)]
63
64use crate::lexer::PtxToken;
65use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
66use crate::r#type::common::*;
67
68pub mod section_0 {
69    use super::*;
70    use crate::r#type::instruction::mma_sp::section_0::*;
71
72    // ============================================================================
73    // Generated enum parsers
74    // ============================================================================
75
76    impl PtxParser for Ctype {
77        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
78            // Try F16
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".f16").is_ok() {
82                    return Ok(Ctype::F16);
83                }
84                stream.set_position(saved_pos);
85            }
86            let saved_pos = stream.position();
87            // Try F32
88            {
89                let saved_pos = stream.position();
90                if stream.expect_string(".f32").is_ok() {
91                    return Ok(Ctype::F32);
92                }
93                stream.set_position(saved_pos);
94            }
95            stream.set_position(saved_pos);
96            let span = stream
97                .peek()
98                .map(|(_, s)| s.clone())
99                .unwrap_or(Span { start: 0, end: 0 });
100            let expected = &[".f16", ".f32"];
101            let found = stream
102                .peek()
103                .map(|(t, _)| format!("{:?}", t))
104                .unwrap_or_else(|_| "<end of input>".to_string());
105            Err(crate::parser::unexpected_value(span, expected, found))
106        }
107    }
108
109    impl PtxParser for Dtype {
110        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
111            // Try F16
112            {
113                let saved_pos = stream.position();
114                if stream.expect_string(".f16").is_ok() {
115                    return Ok(Dtype::F16);
116                }
117                stream.set_position(saved_pos);
118            }
119            let saved_pos = stream.position();
120            // Try F32
121            {
122                let saved_pos = stream.position();
123                if stream.expect_string(".f32").is_ok() {
124                    return Ok(Dtype::F32);
125                }
126                stream.set_position(saved_pos);
127            }
128            stream.set_position(saved_pos);
129            let span = stream
130                .peek()
131                .map(|(_, s)| s.clone())
132                .unwrap_or(Span { start: 0, end: 0 });
133            let expected = &[".f16", ".f32"];
134            let found = stream
135                .peek()
136                .map(|(t, _)| format!("{:?}", t))
137                .unwrap_or_else(|_| "<end of input>".to_string());
138            Err(crate::parser::unexpected_value(span, expected, found))
139        }
140    }
141
142    impl PtxParser for Spvariant {
143        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
144            // Try SpOrderedMetadata
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".sp::ordered_metadata").is_ok() {
148                    return Ok(Spvariant::SpOrderedMetadata);
149                }
150                stream.set_position(saved_pos);
151            }
152            let saved_pos = stream.position();
153            // Try Sp
154            {
155                let saved_pos = stream.position();
156                if stream.expect_string(".sp").is_ok() {
157                    return Ok(Spvariant::Sp);
158                }
159                stream.set_position(saved_pos);
160            }
161            stream.set_position(saved_pos);
162            let span = stream
163                .peek()
164                .map(|(_, s)| s.clone())
165                .unwrap_or(Span { start: 0, end: 0 });
166            let expected = &[".sp::ordered_metadata", ".sp"];
167            let found = stream
168                .peek()
169                .map(|(t, _)| format!("{:?}", t))
170                .unwrap_or_else(|_| "<end of input>".to_string());
171            Err(crate::parser::unexpected_value(span, expected, found))
172        }
173    }
174
175    impl PtxParser for MmaSpvariantSyncAlignedM16n8k16RowColDtypeF16F16Ctype {
176        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
177            stream.expect_string("mma")?;
178            let spvariant = Spvariant::parse(stream)?;
179            stream.expect_complete()?;
180            stream.expect_string(".sync")?;
181            let sync = ();
182            stream.expect_complete()?;
183            stream.expect_string(".aligned")?;
184            let aligned = ();
185            stream.expect_complete()?;
186            stream.expect_string(".m16n8k16")?;
187            let m16n8k16 = ();
188            stream.expect_complete()?;
189            stream.expect_string(".row")?;
190            let row = ();
191            stream.expect_complete()?;
192            stream.expect_string(".col")?;
193            let col = ();
194            stream.expect_complete()?;
195            let dtype = Dtype::parse(stream)?;
196            stream.expect_complete()?;
197            stream.expect_string(".f16")?;
198            let f16 = ();
199            stream.expect_complete()?;
200            stream.expect_string(".f16")?;
201            let f162 = ();
202            stream.expect_complete()?;
203            let ctype = Ctype::parse(stream)?;
204            stream.expect_complete()?;
205            let d = GeneralOperand::parse(stream)?;
206            stream.expect_complete()?;
207            stream.expect(&PtxToken::Comma)?;
208            let a = GeneralOperand::parse(stream)?;
209            stream.expect_complete()?;
210            stream.expect(&PtxToken::Comma)?;
211            let b = GeneralOperand::parse(stream)?;
212            stream.expect_complete()?;
213            stream.expect(&PtxToken::Comma)?;
214            let c = GeneralOperand::parse(stream)?;
215            stream.expect_complete()?;
216            stream.expect(&PtxToken::Comma)?;
217            let e = GeneralOperand::parse(stream)?;
218            stream.expect_complete()?;
219            stream.expect(&PtxToken::Comma)?;
220            let f = GeneralOperand::parse(stream)?;
221            stream.expect_complete()?;
222            stream.expect_complete()?;
223            stream.expect(&PtxToken::Semicolon)?;
224            Ok(MmaSpvariantSyncAlignedM16n8k16RowColDtypeF16F16Ctype {
225                spvariant,
226                sync,
227                aligned,
228                m16n8k16,
229                row,
230                col,
231                dtype,
232                f16,
233                f162,
234                ctype,
235                d,
236                a,
237                b,
238                c,
239                e,
240                f,
241            })
242        }
243    }
244
245    impl PtxParser for MmaSpvariantSyncAlignedM16n8k32RowColDtypeF16F16Ctype {
246        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
247            stream.expect_string("mma")?;
248            let spvariant = Spvariant::parse(stream)?;
249            stream.expect_complete()?;
250            stream.expect_string(".sync")?;
251            let sync = ();
252            stream.expect_complete()?;
253            stream.expect_string(".aligned")?;
254            let aligned = ();
255            stream.expect_complete()?;
256            stream.expect_string(".m16n8k32")?;
257            let m16n8k32 = ();
258            stream.expect_complete()?;
259            stream.expect_string(".row")?;
260            let row = ();
261            stream.expect_complete()?;
262            stream.expect_string(".col")?;
263            let col = ();
264            stream.expect_complete()?;
265            let dtype = Dtype::parse(stream)?;
266            stream.expect_complete()?;
267            stream.expect_string(".f16")?;
268            let f16 = ();
269            stream.expect_complete()?;
270            stream.expect_string(".f16")?;
271            let f162 = ();
272            stream.expect_complete()?;
273            let ctype = Ctype::parse(stream)?;
274            stream.expect_complete()?;
275            let d = GeneralOperand::parse(stream)?;
276            stream.expect_complete()?;
277            stream.expect(&PtxToken::Comma)?;
278            let a = GeneralOperand::parse(stream)?;
279            stream.expect_complete()?;
280            stream.expect(&PtxToken::Comma)?;
281            let b = GeneralOperand::parse(stream)?;
282            stream.expect_complete()?;
283            stream.expect(&PtxToken::Comma)?;
284            let c = GeneralOperand::parse(stream)?;
285            stream.expect_complete()?;
286            stream.expect(&PtxToken::Comma)?;
287            let e = GeneralOperand::parse(stream)?;
288            stream.expect_complete()?;
289            stream.expect(&PtxToken::Comma)?;
290            let f = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect_complete()?;
293            stream.expect(&PtxToken::Semicolon)?;
294            Ok(MmaSpvariantSyncAlignedM16n8k32RowColDtypeF16F16Ctype {
295                spvariant,
296                sync,
297                aligned,
298                m16n8k32,
299                row,
300                col,
301                dtype,
302                f16,
303                f162,
304                ctype,
305                d,
306                a,
307                b,
308                c,
309                e,
310                f,
311            })
312        }
313    }
314}
315
316pub mod section_1 {
317    use super::*;
318    use crate::r#type::instruction::mma_sp::section_1::*;
319
320    // ============================================================================
321    // Generated enum parsers
322    // ============================================================================
323
324    impl PtxParser for Ctype {
325        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
326            // Try F16
327            {
328                let saved_pos = stream.position();
329                if stream.expect_string(".f16").is_ok() {
330                    return Ok(Ctype::F16);
331                }
332                stream.set_position(saved_pos);
333            }
334            let saved_pos = stream.position();
335            // Try F32
336            {
337                let saved_pos = stream.position();
338                if stream.expect_string(".f32").is_ok() {
339                    return Ok(Ctype::F32);
340                }
341                stream.set_position(saved_pos);
342            }
343            stream.set_position(saved_pos);
344            let span = stream
345                .peek()
346                .map(|(_, s)| s.clone())
347                .unwrap_or(Span { start: 0, end: 0 });
348            let expected = &[".f16", ".f32"];
349            let found = stream
350                .peek()
351                .map(|(t, _)| format!("{:?}", t))
352                .unwrap_or_else(|_| "<end of input>".to_string());
353            Err(crate::parser::unexpected_value(span, expected, found))
354        }
355    }
356
357    impl PtxParser for Dtype {
358        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
359            // Try F16
360            {
361                let saved_pos = stream.position();
362                if stream.expect_string(".f16").is_ok() {
363                    return Ok(Dtype::F16);
364                }
365                stream.set_position(saved_pos);
366            }
367            let saved_pos = stream.position();
368            // Try F32
369            {
370                let saved_pos = stream.position();
371                if stream.expect_string(".f32").is_ok() {
372                    return Ok(Dtype::F32);
373                }
374                stream.set_position(saved_pos);
375            }
376            stream.set_position(saved_pos);
377            let span = stream
378                .peek()
379                .map(|(_, s)| s.clone())
380                .unwrap_or(Span { start: 0, end: 0 });
381            let expected = &[".f16", ".f32"];
382            let found = stream
383                .peek()
384                .map(|(t, _)| format!("{:?}", t))
385                .unwrap_or_else(|_| "<end of input>".to_string());
386            Err(crate::parser::unexpected_value(span, expected, found))
387        }
388    }
389
390    impl PtxParser for F8f6f4type {
391        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
392            // Try E4m3
393            {
394                let saved_pos = stream.position();
395                if stream.expect_string(".e4m3").is_ok() {
396                    return Ok(F8f6f4type::E4m3);
397                }
398                stream.set_position(saved_pos);
399            }
400            let saved_pos = stream.position();
401            // Try E5m2
402            {
403                let saved_pos = stream.position();
404                if stream.expect_string(".e5m2").is_ok() {
405                    return Ok(F8f6f4type::E5m2);
406                }
407                stream.set_position(saved_pos);
408            }
409            stream.set_position(saved_pos);
410            let saved_pos = stream.position();
411            // Try E3m2
412            {
413                let saved_pos = stream.position();
414                if stream.expect_string(".e3m2").is_ok() {
415                    return Ok(F8f6f4type::E3m2);
416                }
417                stream.set_position(saved_pos);
418            }
419            stream.set_position(saved_pos);
420            let saved_pos = stream.position();
421            // Try E2m3
422            {
423                let saved_pos = stream.position();
424                if stream.expect_string(".e2m3").is_ok() {
425                    return Ok(F8f6f4type::E2m3);
426                }
427                stream.set_position(saved_pos);
428            }
429            stream.set_position(saved_pos);
430            let saved_pos = stream.position();
431            // Try E2m1
432            {
433                let saved_pos = stream.position();
434                if stream.expect_string(".e2m1").is_ok() {
435                    return Ok(F8f6f4type::E2m1);
436                }
437                stream.set_position(saved_pos);
438            }
439            stream.set_position(saved_pos);
440            let span = stream
441                .peek()
442                .map(|(_, s)| s.clone())
443                .unwrap_or(Span { start: 0, end: 0 });
444            let expected = &[".e4m3", ".e5m2", ".e3m2", ".e2m3", ".e2m1"];
445            let found = stream
446                .peek()
447                .map(|(t, _)| format!("{:?}", t))
448                .unwrap_or_else(|_| "<end of input>".to_string());
449            Err(crate::parser::unexpected_value(span, expected, found))
450        }
451    }
452
453    impl PtxParser for F8type {
454        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
455            // Try E4m3
456            {
457                let saved_pos = stream.position();
458                if stream.expect_string(".e4m3").is_ok() {
459                    return Ok(F8type::E4m3);
460                }
461                stream.set_position(saved_pos);
462            }
463            let saved_pos = stream.position();
464            // Try E5m2
465            {
466                let saved_pos = stream.position();
467                if stream.expect_string(".e5m2").is_ok() {
468                    return Ok(F8type::E5m2);
469                }
470                stream.set_position(saved_pos);
471            }
472            stream.set_position(saved_pos);
473            let span = stream
474                .peek()
475                .map(|(_, s)| s.clone())
476                .unwrap_or(Span { start: 0, end: 0 });
477            let expected = &[".e4m3", ".e5m2"];
478            let found = stream
479                .peek()
480                .map(|(t, _)| format!("{:?}", t))
481                .unwrap_or_else(|_| "<end of input>".to_string());
482            Err(crate::parser::unexpected_value(span, expected, found))
483        }
484    }
485
486    impl PtxParser for Kind {
487        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
488            // Try KindF8f6f4
489            {
490                let saved_pos = stream.position();
491                if stream.expect_string(".kind::f8f6f4").is_ok() {
492                    return Ok(Kind::KindF8f6f4);
493                }
494                stream.set_position(saved_pos);
495            }
496            let span = stream
497                .peek()
498                .map(|(_, s)| s.clone())
499                .unwrap_or(Span { start: 0, end: 0 });
500            let expected = &[".kind::f8f6f4"];
501            let found = stream
502                .peek()
503                .map(|(t, _)| format!("{:?}", t))
504                .unwrap_or_else(|_| "<end of input>".to_string());
505            Err(crate::parser::unexpected_value(span, expected, found))
506        }
507    }
508
509    impl PtxParser for Spvariant {
510        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
511            // Try SpOrderedMetadata
512            {
513                let saved_pos = stream.position();
514                if stream.expect_string(".sp::ordered_metadata").is_ok() {
515                    return Ok(Spvariant::SpOrderedMetadata);
516                }
517                stream.set_position(saved_pos);
518            }
519            let saved_pos = stream.position();
520            // Try Sp
521            {
522                let saved_pos = stream.position();
523                if stream.expect_string(".sp").is_ok() {
524                    return Ok(Spvariant::Sp);
525                }
526                stream.set_position(saved_pos);
527            }
528            stream.set_position(saved_pos);
529            let span = stream
530                .peek()
531                .map(|(_, s)| s.clone())
532                .unwrap_or(Span { start: 0, end: 0 });
533            let expected = &[".sp::ordered_metadata", ".sp"];
534            let found = stream
535                .peek()
536                .map(|(t, _)| format!("{:?}", t))
537                .unwrap_or_else(|_| "<end of input>".to_string());
538            Err(crate::parser::unexpected_value(span, expected, found))
539        }
540    }
541
542    impl PtxParser for MmaSpvariantSyncAlignedM16n8k16RowColF32Bf16Bf16F32 {
543        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
544            stream.expect_string("mma")?;
545            let spvariant = Spvariant::parse(stream)?;
546            stream.expect_complete()?;
547            stream.expect_string(".sync")?;
548            let sync = ();
549            stream.expect_complete()?;
550            stream.expect_string(".aligned")?;
551            let aligned = ();
552            stream.expect_complete()?;
553            stream.expect_string(".m16n8k16")?;
554            let m16n8k16 = ();
555            stream.expect_complete()?;
556            stream.expect_string(".row")?;
557            let row = ();
558            stream.expect_complete()?;
559            stream.expect_string(".col")?;
560            let col = ();
561            stream.expect_complete()?;
562            stream.expect_string(".f32")?;
563            let f32 = ();
564            stream.expect_complete()?;
565            stream.expect_string(".bf16")?;
566            let bf16 = ();
567            stream.expect_complete()?;
568            stream.expect_string(".bf16")?;
569            let bf162 = ();
570            stream.expect_complete()?;
571            stream.expect_string(".f32")?;
572            let f322 = ();
573            stream.expect_complete()?;
574            let d = GeneralOperand::parse(stream)?;
575            stream.expect_complete()?;
576            stream.expect(&PtxToken::Comma)?;
577            let a = GeneralOperand::parse(stream)?;
578            stream.expect_complete()?;
579            stream.expect(&PtxToken::Comma)?;
580            let b = GeneralOperand::parse(stream)?;
581            stream.expect_complete()?;
582            stream.expect(&PtxToken::Comma)?;
583            let c = GeneralOperand::parse(stream)?;
584            stream.expect_complete()?;
585            stream.expect(&PtxToken::Comma)?;
586            let e = GeneralOperand::parse(stream)?;
587            stream.expect_complete()?;
588            stream.expect(&PtxToken::Comma)?;
589            let f = GeneralOperand::parse(stream)?;
590            stream.expect_complete()?;
591            stream.expect_complete()?;
592            stream.expect(&PtxToken::Semicolon)?;
593            Ok(MmaSpvariantSyncAlignedM16n8k16RowColF32Bf16Bf16F32 {
594                spvariant,
595                sync,
596                aligned,
597                m16n8k16,
598                row,
599                col,
600                f32,
601                bf16,
602                bf162,
603                f322,
604                d,
605                a,
606                b,
607                c,
608                e,
609                f,
610            })
611        }
612    }
613
614    impl PtxParser for MmaSpvariantSyncAlignedM16n8k32RowColF32Bf16Bf16F32 {
615        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
616            stream.expect_string("mma")?;
617            let spvariant = Spvariant::parse(stream)?;
618            stream.expect_complete()?;
619            stream.expect_string(".sync")?;
620            let sync = ();
621            stream.expect_complete()?;
622            stream.expect_string(".aligned")?;
623            let aligned = ();
624            stream.expect_complete()?;
625            stream.expect_string(".m16n8k32")?;
626            let m16n8k32 = ();
627            stream.expect_complete()?;
628            stream.expect_string(".row")?;
629            let row = ();
630            stream.expect_complete()?;
631            stream.expect_string(".col")?;
632            let col = ();
633            stream.expect_complete()?;
634            stream.expect_string(".f32")?;
635            let f32 = ();
636            stream.expect_complete()?;
637            stream.expect_string(".bf16")?;
638            let bf16 = ();
639            stream.expect_complete()?;
640            stream.expect_string(".bf16")?;
641            let bf162 = ();
642            stream.expect_complete()?;
643            stream.expect_string(".f32")?;
644            let f322 = ();
645            stream.expect_complete()?;
646            let d = GeneralOperand::parse(stream)?;
647            stream.expect_complete()?;
648            stream.expect(&PtxToken::Comma)?;
649            let a = GeneralOperand::parse(stream)?;
650            stream.expect_complete()?;
651            stream.expect(&PtxToken::Comma)?;
652            let b = GeneralOperand::parse(stream)?;
653            stream.expect_complete()?;
654            stream.expect(&PtxToken::Comma)?;
655            let c = GeneralOperand::parse(stream)?;
656            stream.expect_complete()?;
657            stream.expect(&PtxToken::Comma)?;
658            let e = GeneralOperand::parse(stream)?;
659            stream.expect_complete()?;
660            stream.expect(&PtxToken::Comma)?;
661            let f = GeneralOperand::parse(stream)?;
662            stream.expect_complete()?;
663            stream.expect_complete()?;
664            stream.expect(&PtxToken::Semicolon)?;
665            Ok(MmaSpvariantSyncAlignedM16n8k32RowColF32Bf16Bf16F32 {
666                spvariant,
667                sync,
668                aligned,
669                m16n8k32,
670                row,
671                col,
672                f32,
673                bf16,
674                bf162,
675                f322,
676                d,
677                a,
678                b,
679                c,
680                e,
681                f,
682            })
683        }
684    }
685
686    impl PtxParser for MmaSpvariantSyncAlignedM16n8k8RowColF32Tf32Tf32F32 {
687        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
688            stream.expect_string("mma")?;
689            let spvariant = Spvariant::parse(stream)?;
690            stream.expect_complete()?;
691            stream.expect_string(".sync")?;
692            let sync = ();
693            stream.expect_complete()?;
694            stream.expect_string(".aligned")?;
695            let aligned = ();
696            stream.expect_complete()?;
697            stream.expect_string(".m16n8k8")?;
698            let m16n8k8 = ();
699            stream.expect_complete()?;
700            stream.expect_string(".row")?;
701            let row = ();
702            stream.expect_complete()?;
703            stream.expect_string(".col")?;
704            let col = ();
705            stream.expect_complete()?;
706            stream.expect_string(".f32")?;
707            let f32 = ();
708            stream.expect_complete()?;
709            stream.expect_string(".tf32")?;
710            let tf32 = ();
711            stream.expect_complete()?;
712            stream.expect_string(".tf32")?;
713            let tf322 = ();
714            stream.expect_complete()?;
715            stream.expect_string(".f32")?;
716            let f322 = ();
717            stream.expect_complete()?;
718            let d = GeneralOperand::parse(stream)?;
719            stream.expect_complete()?;
720            stream.expect(&PtxToken::Comma)?;
721            let a = GeneralOperand::parse(stream)?;
722            stream.expect_complete()?;
723            stream.expect(&PtxToken::Comma)?;
724            let b = GeneralOperand::parse(stream)?;
725            stream.expect_complete()?;
726            stream.expect(&PtxToken::Comma)?;
727            let c = GeneralOperand::parse(stream)?;
728            stream.expect_complete()?;
729            stream.expect(&PtxToken::Comma)?;
730            let e = GeneralOperand::parse(stream)?;
731            stream.expect_complete()?;
732            stream.expect(&PtxToken::Comma)?;
733            let f = GeneralOperand::parse(stream)?;
734            stream.expect_complete()?;
735            stream.expect_complete()?;
736            stream.expect(&PtxToken::Semicolon)?;
737            Ok(MmaSpvariantSyncAlignedM16n8k8RowColF32Tf32Tf32F32 {
738                spvariant,
739                sync,
740                aligned,
741                m16n8k8,
742                row,
743                col,
744                f32,
745                tf32,
746                tf322,
747                f322,
748                d,
749                a,
750                b,
751                c,
752                e,
753                f,
754            })
755        }
756    }
757
758    impl PtxParser for MmaSpvariantSyncAlignedM16n8k16RowColF32Tf32Tf32F32 {
759        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
760            stream.expect_string("mma")?;
761            let spvariant = Spvariant::parse(stream)?;
762            stream.expect_complete()?;
763            stream.expect_string(".sync")?;
764            let sync = ();
765            stream.expect_complete()?;
766            stream.expect_string(".aligned")?;
767            let aligned = ();
768            stream.expect_complete()?;
769            stream.expect_string(".m16n8k16")?;
770            let m16n8k16 = ();
771            stream.expect_complete()?;
772            stream.expect_string(".row")?;
773            let row = ();
774            stream.expect_complete()?;
775            stream.expect_string(".col")?;
776            let col = ();
777            stream.expect_complete()?;
778            stream.expect_string(".f32")?;
779            let f32 = ();
780            stream.expect_complete()?;
781            stream.expect_string(".tf32")?;
782            let tf32 = ();
783            stream.expect_complete()?;
784            stream.expect_string(".tf32")?;
785            let tf322 = ();
786            stream.expect_complete()?;
787            stream.expect_string(".f32")?;
788            let f322 = ();
789            stream.expect_complete()?;
790            let d = GeneralOperand::parse(stream)?;
791            stream.expect_complete()?;
792            stream.expect(&PtxToken::Comma)?;
793            let a = GeneralOperand::parse(stream)?;
794            stream.expect_complete()?;
795            stream.expect(&PtxToken::Comma)?;
796            let b = GeneralOperand::parse(stream)?;
797            stream.expect_complete()?;
798            stream.expect(&PtxToken::Comma)?;
799            let c = GeneralOperand::parse(stream)?;
800            stream.expect_complete()?;
801            stream.expect(&PtxToken::Comma)?;
802            let e = GeneralOperand::parse(stream)?;
803            stream.expect_complete()?;
804            stream.expect(&PtxToken::Comma)?;
805            let f = GeneralOperand::parse(stream)?;
806            stream.expect_complete()?;
807            stream.expect_complete()?;
808            stream.expect(&PtxToken::Semicolon)?;
809            Ok(MmaSpvariantSyncAlignedM16n8k16RowColF32Tf32Tf32F32 {
810                spvariant,
811                sync,
812                aligned,
813                m16n8k16,
814                row,
815                col,
816                f32,
817                tf32,
818                tf322,
819                f322,
820                d,
821                a,
822                b,
823                c,
824                e,
825                f,
826            })
827        }
828    }
829
830    impl PtxParser for MmaSpvariantSyncAlignedM16n8k64RowColF32F8typeF8typeF32 {
831        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
832            stream.expect_string("mma")?;
833            let spvariant = Spvariant::parse(stream)?;
834            stream.expect_complete()?;
835            stream.expect_string(".sync")?;
836            let sync = ();
837            stream.expect_complete()?;
838            stream.expect_string(".aligned")?;
839            let aligned = ();
840            stream.expect_complete()?;
841            stream.expect_string(".m16n8k64")?;
842            let m16n8k64 = ();
843            stream.expect_complete()?;
844            stream.expect_string(".row")?;
845            let row = ();
846            stream.expect_complete()?;
847            stream.expect_string(".col")?;
848            let col = ();
849            stream.expect_complete()?;
850            stream.expect_string(".f32")?;
851            let f32 = ();
852            stream.expect_complete()?;
853            let f8type = F8type::parse(stream)?;
854            stream.expect_complete()?;
855            let f8type1 = F8type::parse(stream)?;
856            stream.expect_complete()?;
857            stream.expect_string(".f32")?;
858            let f322 = ();
859            stream.expect_complete()?;
860            let d = GeneralOperand::parse(stream)?;
861            stream.expect_complete()?;
862            stream.expect(&PtxToken::Comma)?;
863            let a = GeneralOperand::parse(stream)?;
864            stream.expect_complete()?;
865            stream.expect(&PtxToken::Comma)?;
866            let b = GeneralOperand::parse(stream)?;
867            stream.expect_complete()?;
868            stream.expect(&PtxToken::Comma)?;
869            let c = GeneralOperand::parse(stream)?;
870            stream.expect_complete()?;
871            stream.expect(&PtxToken::Comma)?;
872            let e = GeneralOperand::parse(stream)?;
873            stream.expect_complete()?;
874            stream.expect(&PtxToken::Comma)?;
875            let f = GeneralOperand::parse(stream)?;
876            stream.expect_complete()?;
877            stream.expect_complete()?;
878            stream.expect(&PtxToken::Semicolon)?;
879            Ok(MmaSpvariantSyncAlignedM16n8k64RowColF32F8typeF8typeF32 {
880                spvariant,
881                sync,
882                aligned,
883                m16n8k64,
884                row,
885                col,
886                f32,
887                f8type,
888                f8type1,
889                f322,
890                d,
891                a,
892                b,
893                c,
894                e,
895                f,
896            })
897        }
898    }
899
900    impl PtxParser for MmaSpOrderedMetadataSyncAlignedM16n8k64RowColKindDtypeF8f6f4typeF8f6f4typeCtype {
901        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
902            stream.expect_string("mma")?;
903            stream.expect_string(".sp::ordered_metadata")?;
904            let sp_ordered_metadata = ();
905            stream.expect_complete()?;
906            stream.expect_string(".sync")?;
907            let sync = ();
908            stream.expect_complete()?;
909            stream.expect_string(".aligned")?;
910            let aligned = ();
911            stream.expect_complete()?;
912            stream.expect_string(".m16n8k64")?;
913            let m16n8k64 = ();
914            stream.expect_complete()?;
915            stream.expect_string(".row")?;
916            let row = ();
917            stream.expect_complete()?;
918            stream.expect_string(".col")?;
919            let col = ();
920            stream.expect_complete()?;
921            let kind = Kind::parse(stream)?;
922            stream.expect_complete()?;
923            let dtype = Dtype::parse(stream)?;
924            stream.expect_complete()?;
925            let f8f6f4type = F8f6f4type::parse(stream)?;
926            stream.expect_complete()?;
927            let f8f6f4type1 = F8f6f4type::parse(stream)?;
928            stream.expect_complete()?;
929            let ctype = Ctype::parse(stream)?;
930            stream.expect_complete()?;
931            let d = GeneralOperand::parse(stream)?;
932            stream.expect_complete()?;
933            stream.expect(&PtxToken::Comma)?;
934            let a = GeneralOperand::parse(stream)?;
935            stream.expect_complete()?;
936            stream.expect(&PtxToken::Comma)?;
937            let b = GeneralOperand::parse(stream)?;
938            stream.expect_complete()?;
939            stream.expect(&PtxToken::Comma)?;
940            let c = GeneralOperand::parse(stream)?;
941            stream.expect_complete()?;
942            stream.expect(&PtxToken::Comma)?;
943            let e = GeneralOperand::parse(stream)?;
944            stream.expect_complete()?;
945            stream.expect(&PtxToken::Comma)?;
946            let f = GeneralOperand::parse(stream)?;
947            stream.expect_complete()?;
948            stream.expect_complete()?;
949            stream.expect(&PtxToken::Semicolon)?;
950            Ok(
951                MmaSpOrderedMetadataSyncAlignedM16n8k64RowColKindDtypeF8f6f4typeF8f6f4typeCtype {
952                    sp_ordered_metadata,
953                    sync,
954                    aligned,
955                    m16n8k64,
956                    row,
957                    col,
958                    kind,
959                    dtype,
960                    f8f6f4type,
961                    f8f6f4type1,
962                    ctype,
963                    d,
964                    a,
965                    b,
966                    c,
967                    e,
968                    f,
969                },
970            )
971        }
972    }
973}
974
975pub mod section_2 {
976    use super::*;
977    use crate::r#type::instruction::mma_sp::section_2::*;
978
979    // ============================================================================
980    // Generated enum parsers
981    // ============================================================================
982
983    impl PtxParser for Kind {
984        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
985            // Try KindMxf4
986            {
987                let saved_pos = stream.position();
988                if stream.expect_string(".kind::mxf4").is_ok() {
989                    return Ok(Kind::KindMxf4);
990                }
991                stream.set_position(saved_pos);
992            }
993            let span = stream
994                .peek()
995                .map(|(_, s)| s.clone())
996                .unwrap_or(Span { start: 0, end: 0 });
997            let expected = &[".kind::mxf4"];
998            let found = stream
999                .peek()
1000                .map(|(t, _)| format!("{:?}", t))
1001                .unwrap_or_else(|_| "<end of input>".to_string());
1002            Err(crate::parser::unexpected_value(span, expected, found))
1003        }
1004    }
1005
1006    impl PtxParser for ScaleVecSize {
1007        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1008            // Try ScaleVec2x
1009            {
1010                let saved_pos = stream.position();
1011                if stream.expect_string(".scale_vec::2X").is_ok() {
1012                    return Ok(ScaleVecSize::ScaleVec2x);
1013                }
1014                stream.set_position(saved_pos);
1015            }
1016            let span = stream
1017                .peek()
1018                .map(|(_, s)| s.clone())
1019                .unwrap_or(Span { start: 0, end: 0 });
1020            let expected = &[".scale_vec::2X"];
1021            let found = stream
1022                .peek()
1023                .map(|(t, _)| format!("{:?}", t))
1024                .unwrap_or_else(|_| "<end of input>".to_string());
1025            Err(crate::parser::unexpected_value(span, expected, found))
1026        }
1027    }
1028
1029    impl PtxParser for Spvariant {
1030        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1031            // Try SpOrderedMetadata
1032            {
1033                let saved_pos = stream.position();
1034                if stream.expect_string(".sp::ordered_metadata").is_ok() {
1035                    return Ok(Spvariant::SpOrderedMetadata);
1036                }
1037                stream.set_position(saved_pos);
1038            }
1039            let span = stream
1040                .peek()
1041                .map(|(_, s)| s.clone())
1042                .unwrap_or(Span { start: 0, end: 0 });
1043            let expected = &[".sp::ordered_metadata"];
1044            let found = stream
1045                .peek()
1046                .map(|(t, _)| format!("{:?}", t))
1047                .unwrap_or_else(|_| "<end of input>".to_string());
1048            Err(crate::parser::unexpected_value(span, expected, found))
1049        }
1050    }
1051
1052    impl PtxParser for Stype {
1053        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1054            // Try Ue8m0
1055            {
1056                let saved_pos = stream.position();
1057                if stream.expect_string(".ue8m0").is_ok() {
1058                    return Ok(Stype::Ue8m0);
1059                }
1060                stream.set_position(saved_pos);
1061            }
1062            let span = stream
1063                .peek()
1064                .map(|(_, s)| s.clone())
1065                .unwrap_or(Span { start: 0, end: 0 });
1066            let expected = &[".ue8m0"];
1067            let found = stream
1068                .peek()
1069                .map(|(t, _)| format!("{:?}", t))
1070                .unwrap_or_else(|_| "<end of input>".to_string());
1071            Err(crate::parser::unexpected_value(span, expected, found))
1072        }
1073    }
1074
1075    impl PtxParser
1076        for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype
1077    {
1078        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1079            stream.expect_string("mma")?;
1080            let spvariant = Spvariant::parse(stream)?;
1081            stream.expect_complete()?;
1082            stream.expect_string(".sync")?;
1083            let sync = ();
1084            stream.expect_complete()?;
1085            stream.expect_string(".aligned")?;
1086            let aligned = ();
1087            stream.expect_complete()?;
1088            stream.expect_string(".m16n8k128")?;
1089            let m16n8k128 = ();
1090            stream.expect_complete()?;
1091            stream.expect_string(".row")?;
1092            let row = ();
1093            stream.expect_complete()?;
1094            stream.expect_string(".col")?;
1095            let col = ();
1096            stream.expect_complete()?;
1097            let kind = Kind::parse(stream)?;
1098            stream.expect_complete()?;
1099            stream.expect_string(".block_scale")?;
1100            let block_scale = ();
1101            stream.expect_complete()?;
1102            let saved_pos = stream.position();
1103            let scale_vec_size = match ScaleVecSize::parse(stream) {
1104                Ok(val) => Some(val),
1105                Err(_) => {
1106                    stream.set_position(saved_pos);
1107                    None
1108                }
1109            };
1110            stream.expect_complete()?;
1111            stream.expect_string(".f32")?;
1112            let f32 = ();
1113            stream.expect_complete()?;
1114            stream.expect_string(".e2m1")?;
1115            let e2m1 = ();
1116            stream.expect_complete()?;
1117            stream.expect_string(".e2m1")?;
1118            let e2m12 = ();
1119            stream.expect_complete()?;
1120            stream.expect_string(".f32")?;
1121            let f322 = ();
1122            stream.expect_complete()?;
1123            let stype = Stype::parse(stream)?;
1124            stream.expect_complete()?;
1125            let d = GeneralOperand::parse(stream)?;
1126            stream.expect_complete()?;
1127            stream.expect(&PtxToken::Comma)?;
1128            let a = GeneralOperand::parse(stream)?;
1129            stream.expect_complete()?;
1130            stream.expect(&PtxToken::Comma)?;
1131            let b = GeneralOperand::parse(stream)?;
1132            stream.expect_complete()?;
1133            stream.expect(&PtxToken::Comma)?;
1134            let c = GeneralOperand::parse(stream)?;
1135            stream.expect_complete()?;
1136            stream.expect(&PtxToken::Comma)?;
1137            let e = GeneralOperand::parse(stream)?;
1138            stream.expect_complete()?;
1139            stream.expect(&PtxToken::Comma)?;
1140            let f = GeneralOperand::parse(stream)?;
1141            stream.expect_complete()?;
1142            stream.expect(&PtxToken::Comma)?;
1143            let scale_a_data = GeneralOperand::parse(stream)?;
1144            stream.expect_complete()?;
1145            stream.expect(&PtxToken::Comma)?;
1146            let byte_id_a = VectorOperand::parse(stream)?;
1147            stream.expect_complete()?;
1148            stream.expect(&PtxToken::Comma)?;
1149            let scale_b_data = GeneralOperand::parse(stream)?;
1150            stream.expect_complete()?;
1151            stream.expect(&PtxToken::Comma)?;
1152            let byte_id_b = VectorOperand::parse(stream)?;
1153            stream.expect_complete()?;
1154            stream.expect_complete()?;
1155            stream.expect(&PtxToken::Semicolon)?;
1156            Ok(MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype {
1157                spvariant,
1158                sync,
1159                aligned,
1160                m16n8k128,
1161                row,
1162                col,
1163                kind,
1164                block_scale,
1165                scale_vec_size,
1166                f32,
1167                e2m1,
1168                e2m12,
1169                f322,
1170                stype,
1171                d,
1172                a,
1173                b,
1174                c,
1175                e,
1176                f,
1177                scale_a_data,
1178                byte_id_a,
1179                scale_b_data,
1180                byte_id_b,
1181            })
1182        }
1183    }
1184}
1185
1186pub mod section_3 {
1187    use super::*;
1188    use crate::r#type::instruction::mma_sp::section_3::*;
1189
1190    // ============================================================================
1191    // Generated enum parsers
1192    // ============================================================================
1193
1194    impl PtxParser for Kind {
1195        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1196            // Try KindMxf4nvf4
1197            {
1198                let saved_pos = stream.position();
1199                if stream.expect_string(".kind::mxf4nvf4").is_ok() {
1200                    return Ok(Kind::KindMxf4nvf4);
1201                }
1202                stream.set_position(saved_pos);
1203            }
1204            let span = stream
1205                .peek()
1206                .map(|(_, s)| s.clone())
1207                .unwrap_or(Span { start: 0, end: 0 });
1208            let expected = &[".kind::mxf4nvf4"];
1209            let found = stream
1210                .peek()
1211                .map(|(t, _)| format!("{:?}", t))
1212                .unwrap_or_else(|_| "<end of input>".to_string());
1213            Err(crate::parser::unexpected_value(span, expected, found))
1214        }
1215    }
1216
1217    impl PtxParser for ScaleVecSize {
1218        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1219            // Try ScaleVec2x
1220            {
1221                let saved_pos = stream.position();
1222                if stream.expect_string(".scale_vec::2X").is_ok() {
1223                    return Ok(ScaleVecSize::ScaleVec2x);
1224                }
1225                stream.set_position(saved_pos);
1226            }
1227            let saved_pos = stream.position();
1228            // Try ScaleVec4x
1229            {
1230                let saved_pos = stream.position();
1231                if stream.expect_string(".scale_vec::4X").is_ok() {
1232                    return Ok(ScaleVecSize::ScaleVec4x);
1233                }
1234                stream.set_position(saved_pos);
1235            }
1236            stream.set_position(saved_pos);
1237            let span = stream
1238                .peek()
1239                .map(|(_, s)| s.clone())
1240                .unwrap_or(Span { start: 0, end: 0 });
1241            let expected = &[".scale_vec::2X", ".scale_vec::4X"];
1242            let found = stream
1243                .peek()
1244                .map(|(t, _)| format!("{:?}", t))
1245                .unwrap_or_else(|_| "<end of input>".to_string());
1246            Err(crate::parser::unexpected_value(span, expected, found))
1247        }
1248    }
1249
1250    impl PtxParser for Spvariant {
1251        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1252            // Try SpOrderedMetadata
1253            {
1254                let saved_pos = stream.position();
1255                if stream.expect_string(".sp::ordered_metadata").is_ok() {
1256                    return Ok(Spvariant::SpOrderedMetadata);
1257                }
1258                stream.set_position(saved_pos);
1259            }
1260            let span = stream
1261                .peek()
1262                .map(|(_, s)| s.clone())
1263                .unwrap_or(Span { start: 0, end: 0 });
1264            let expected = &[".sp::ordered_metadata"];
1265            let found = stream
1266                .peek()
1267                .map(|(t, _)| format!("{:?}", t))
1268                .unwrap_or_else(|_| "<end of input>".to_string());
1269            Err(crate::parser::unexpected_value(span, expected, found))
1270        }
1271    }
1272
1273    impl PtxParser for Stype {
1274        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1275            // Try Ue8m0
1276            {
1277                let saved_pos = stream.position();
1278                if stream.expect_string(".ue8m0").is_ok() {
1279                    return Ok(Stype::Ue8m0);
1280                }
1281                stream.set_position(saved_pos);
1282            }
1283            let saved_pos = stream.position();
1284            // Try Ue4m3
1285            {
1286                let saved_pos = stream.position();
1287                if stream.expect_string(".ue4m3").is_ok() {
1288                    return Ok(Stype::Ue4m3);
1289                }
1290                stream.set_position(saved_pos);
1291            }
1292            stream.set_position(saved_pos);
1293            let span = stream
1294                .peek()
1295                .map(|(_, s)| s.clone())
1296                .unwrap_or(Span { start: 0, end: 0 });
1297            let expected = &[".ue8m0", ".ue4m3"];
1298            let found = stream
1299                .peek()
1300                .map(|(t, _)| format!("{:?}", t))
1301                .unwrap_or_else(|_| "<end of input>".to_string());
1302            Err(crate::parser::unexpected_value(span, expected, found))
1303        }
1304    }
1305
1306    impl PtxParser
1307        for MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype1
1308    {
1309        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1310            stream.expect_string("mma")?;
1311            let spvariant = Spvariant::parse(stream)?;
1312            stream.expect_complete()?;
1313            stream.expect_string(".sync")?;
1314            let sync = ();
1315            stream.expect_complete()?;
1316            stream.expect_string(".aligned")?;
1317            let aligned = ();
1318            stream.expect_complete()?;
1319            stream.expect_string(".m16n8k128")?;
1320            let m16n8k128 = ();
1321            stream.expect_complete()?;
1322            stream.expect_string(".row")?;
1323            let row = ();
1324            stream.expect_complete()?;
1325            stream.expect_string(".col")?;
1326            let col = ();
1327            stream.expect_complete()?;
1328            let kind = Kind::parse(stream)?;
1329            stream.expect_complete()?;
1330            stream.expect_string(".block_scale")?;
1331            let block_scale = ();
1332            stream.expect_complete()?;
1333            let scale_vec_size = ScaleVecSize::parse(stream)?;
1334            stream.expect_complete()?;
1335            stream.expect_string(".f32")?;
1336            let f32 = ();
1337            stream.expect_complete()?;
1338            stream.expect_string(".e2m1")?;
1339            let e2m1 = ();
1340            stream.expect_complete()?;
1341            stream.expect_string(".e2m1")?;
1342            let e2m12 = ();
1343            stream.expect_complete()?;
1344            stream.expect_string(".f32")?;
1345            let f322 = ();
1346            stream.expect_complete()?;
1347            let stype = Stype::parse(stream)?;
1348            stream.expect_complete()?;
1349            let d = GeneralOperand::parse(stream)?;
1350            stream.expect_complete()?;
1351            stream.expect(&PtxToken::Comma)?;
1352            let a = GeneralOperand::parse(stream)?;
1353            stream.expect_complete()?;
1354            stream.expect(&PtxToken::Comma)?;
1355            let b = GeneralOperand::parse(stream)?;
1356            stream.expect_complete()?;
1357            stream.expect(&PtxToken::Comma)?;
1358            let c = GeneralOperand::parse(stream)?;
1359            stream.expect_complete()?;
1360            stream.expect(&PtxToken::Comma)?;
1361            let e = GeneralOperand::parse(stream)?;
1362            stream.expect_complete()?;
1363            stream.expect(&PtxToken::Comma)?;
1364            let f = GeneralOperand::parse(stream)?;
1365            stream.expect_complete()?;
1366            stream.expect(&PtxToken::Comma)?;
1367            let scale_a_data = GeneralOperand::parse(stream)?;
1368            stream.expect_complete()?;
1369            stream.expect(&PtxToken::Comma)?;
1370            let byte_id_a = VectorOperand::parse(stream)?;
1371            stream.expect_complete()?;
1372            stream.expect(&PtxToken::Comma)?;
1373            let scale_b_data = GeneralOperand::parse(stream)?;
1374            stream.expect_complete()?;
1375            stream.expect(&PtxToken::Comma)?;
1376            let byte_id_b = VectorOperand::parse(stream)?;
1377            stream.expect_complete()?;
1378            stream.expect_complete()?;
1379            stream.expect(&PtxToken::Semicolon)?;
1380            Ok(MmaSpvariantSyncAlignedM16n8k128RowColKindBlockScaleScaleVecSizeF32E2m1E2m1F32Stype1 {
1381                spvariant,
1382                sync,
1383                aligned,
1384                m16n8k128,
1385                row,
1386                col,
1387                kind,
1388                block_scale,
1389                scale_vec_size,
1390                f32,
1391                e2m1,
1392                e2m12,
1393                f322,
1394                stype,
1395                d,
1396                a,
1397                b,
1398                c,
1399                e,
1400                f,
1401                scale_a_data,
1402                byte_id_a,
1403                scale_b_data,
1404                byte_id_b,
1405            })
1406        }
1407    }
1408}
1409
1410pub mod section_4 {
1411    use super::*;
1412    use crate::r#type::instruction::mma_sp::section_4::*;
1413
1414    // ============================================================================
1415    // Generated enum parsers
1416    // ============================================================================
1417
1418    impl PtxParser for F8f6f4type {
1419        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1420            // Try E4m3
1421            {
1422                let saved_pos = stream.position();
1423                if stream.expect_string(".e4m3").is_ok() {
1424                    return Ok(F8f6f4type::E4m3);
1425                }
1426                stream.set_position(saved_pos);
1427            }
1428            let saved_pos = stream.position();
1429            // Try E5m2
1430            {
1431                let saved_pos = stream.position();
1432                if stream.expect_string(".e5m2").is_ok() {
1433                    return Ok(F8f6f4type::E5m2);
1434                }
1435                stream.set_position(saved_pos);
1436            }
1437            stream.set_position(saved_pos);
1438            let saved_pos = stream.position();
1439            // Try E3m2
1440            {
1441                let saved_pos = stream.position();
1442                if stream.expect_string(".e3m2").is_ok() {
1443                    return Ok(F8f6f4type::E3m2);
1444                }
1445                stream.set_position(saved_pos);
1446            }
1447            stream.set_position(saved_pos);
1448            let saved_pos = stream.position();
1449            // Try E2m3
1450            {
1451                let saved_pos = stream.position();
1452                if stream.expect_string(".e2m3").is_ok() {
1453                    return Ok(F8f6f4type::E2m3);
1454                }
1455                stream.set_position(saved_pos);
1456            }
1457            stream.set_position(saved_pos);
1458            let saved_pos = stream.position();
1459            // Try E2m1
1460            {
1461                let saved_pos = stream.position();
1462                if stream.expect_string(".e2m1").is_ok() {
1463                    return Ok(F8f6f4type::E2m1);
1464                }
1465                stream.set_position(saved_pos);
1466            }
1467            stream.set_position(saved_pos);
1468            let span = stream
1469                .peek()
1470                .map(|(_, s)| s.clone())
1471                .unwrap_or(Span { start: 0, end: 0 });
1472            let expected = &[".e4m3", ".e5m2", ".e3m2", ".e2m3", ".e2m1"];
1473            let found = stream
1474                .peek()
1475                .map(|(t, _)| format!("{:?}", t))
1476                .unwrap_or_else(|_| "<end of input>".to_string());
1477            Err(crate::parser::unexpected_value(span, expected, found))
1478        }
1479    }
1480
1481    impl PtxParser for Kind {
1482        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1483            // Try KindMxf8f6f4
1484            {
1485                let saved_pos = stream.position();
1486                if stream.expect_string(".kind::mxf8f6f4").is_ok() {
1487                    return Ok(Kind::KindMxf8f6f4);
1488                }
1489                stream.set_position(saved_pos);
1490            }
1491            let span = stream
1492                .peek()
1493                .map(|(_, s)| s.clone())
1494                .unwrap_or(Span { start: 0, end: 0 });
1495            let expected = &[".kind::mxf8f6f4"];
1496            let found = stream
1497                .peek()
1498                .map(|(t, _)| format!("{:?}", t))
1499                .unwrap_or_else(|_| "<end of input>".to_string());
1500            Err(crate::parser::unexpected_value(span, expected, found))
1501        }
1502    }
1503
1504    impl PtxParser for ScaleVecSize {
1505        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1506            // Try ScaleVec1x
1507            {
1508                let saved_pos = stream.position();
1509                if stream.expect_string(".scale_vec::1X").is_ok() {
1510                    return Ok(ScaleVecSize::ScaleVec1x);
1511                }
1512                stream.set_position(saved_pos);
1513            }
1514            let span = stream
1515                .peek()
1516                .map(|(_, s)| s.clone())
1517                .unwrap_or(Span { start: 0, end: 0 });
1518            let expected = &[".scale_vec::1X"];
1519            let found = stream
1520                .peek()
1521                .map(|(t, _)| format!("{:?}", t))
1522                .unwrap_or_else(|_| "<end of input>".to_string());
1523            Err(crate::parser::unexpected_value(span, expected, found))
1524        }
1525    }
1526
1527    impl PtxParser for Spvariant {
1528        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1529            // Try SpOrderedMetadata
1530            {
1531                let saved_pos = stream.position();
1532                if stream.expect_string(".sp::ordered_metadata").is_ok() {
1533                    return Ok(Spvariant::SpOrderedMetadata);
1534                }
1535                stream.set_position(saved_pos);
1536            }
1537            let span = stream
1538                .peek()
1539                .map(|(_, s)| s.clone())
1540                .unwrap_or(Span { start: 0, end: 0 });
1541            let expected = &[".sp::ordered_metadata"];
1542            let found = stream
1543                .peek()
1544                .map(|(t, _)| format!("{:?}", t))
1545                .unwrap_or_else(|_| "<end of input>".to_string());
1546            Err(crate::parser::unexpected_value(span, expected, found))
1547        }
1548    }
1549
1550    impl PtxParser for Stype {
1551        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1552            // Try Ue8m0
1553            {
1554                let saved_pos = stream.position();
1555                if stream.expect_string(".ue8m0").is_ok() {
1556                    return Ok(Stype::Ue8m0);
1557                }
1558                stream.set_position(saved_pos);
1559            }
1560            let span = stream
1561                .peek()
1562                .map(|(_, s)| s.clone())
1563                .unwrap_or(Span { start: 0, end: 0 });
1564            let expected = &[".ue8m0"];
1565            let found = stream
1566                .peek()
1567                .map(|(t, _)| format!("{:?}", t))
1568                .unwrap_or_else(|_| "<end of input>".to_string());
1569            Err(crate::parser::unexpected_value(span, expected, found))
1570        }
1571    }
1572
1573    impl PtxParser for MmaSpvariantSyncAlignedM16n8k64RowColKindBlockScaleScaleVecSizeF32F8f6f4typeF8f6f4typeF32Stype {
1574        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1575            stream.expect_string("mma")?;
1576            let spvariant = Spvariant::parse(stream)?;
1577            stream.expect_complete()?;
1578            stream.expect_string(".sync")?;
1579            let sync = ();
1580            stream.expect_complete()?;
1581            stream.expect_string(".aligned")?;
1582            let aligned = ();
1583            stream.expect_complete()?;
1584            stream.expect_string(".m16n8k64")?;
1585            let m16n8k64 = ();
1586            stream.expect_complete()?;
1587            stream.expect_string(".row")?;
1588            let row = ();
1589            stream.expect_complete()?;
1590            stream.expect_string(".col")?;
1591            let col = ();
1592            stream.expect_complete()?;
1593            let kind = Kind::parse(stream)?;
1594            stream.expect_complete()?;
1595            stream.expect_string(".block_scale")?;
1596            let block_scale = ();
1597            stream.expect_complete()?;
1598            let saved_pos = stream.position();
1599            let scale_vec_size = match ScaleVecSize::parse(stream) {
1600                Ok(val) => Some(val),
1601                Err(_) => {
1602                    stream.set_position(saved_pos);
1603                    None
1604                }
1605            };
1606            stream.expect_complete()?;
1607            stream.expect_string(".f32")?;
1608            let f32 = ();
1609            stream.expect_complete()?;
1610            let f8f6f4type = F8f6f4type::parse(stream)?;
1611            stream.expect_complete()?;
1612            let f8f6f4type1 = F8f6f4type::parse(stream)?;
1613            stream.expect_complete()?;
1614            stream.expect_string(".f32")?;
1615            let f322 = ();
1616            stream.expect_complete()?;
1617            let stype = Stype::parse(stream)?;
1618            stream.expect_complete()?;
1619            let d = GeneralOperand::parse(stream)?;
1620            stream.expect_complete()?;
1621            stream.expect(&PtxToken::Comma)?;
1622            let a = GeneralOperand::parse(stream)?;
1623            stream.expect_complete()?;
1624            stream.expect(&PtxToken::Comma)?;
1625            let b = GeneralOperand::parse(stream)?;
1626            stream.expect_complete()?;
1627            stream.expect(&PtxToken::Comma)?;
1628            let c = GeneralOperand::parse(stream)?;
1629            stream.expect_complete()?;
1630            stream.expect(&PtxToken::Comma)?;
1631            let e = GeneralOperand::parse(stream)?;
1632            stream.expect_complete()?;
1633            stream.expect(&PtxToken::Comma)?;
1634            let f = GeneralOperand::parse(stream)?;
1635            stream.expect_complete()?;
1636            stream.expect(&PtxToken::Comma)?;
1637            let scale_a_data = GeneralOperand::parse(stream)?;
1638            stream.expect_complete()?;
1639            stream.expect(&PtxToken::Comma)?;
1640            let byte_id_a = VectorOperand::parse(stream)?;
1641            stream.expect_complete()?;
1642            stream.expect(&PtxToken::Comma)?;
1643            let scale_b_data = GeneralOperand::parse(stream)?;
1644            stream.expect_complete()?;
1645            stream.expect(&PtxToken::Comma)?;
1646            let byte_id_b = VectorOperand::parse(stream)?;
1647            stream.expect_complete()?;
1648            stream.expect_complete()?;
1649            stream.expect(&PtxToken::Semicolon)?;
1650            Ok(MmaSpvariantSyncAlignedM16n8k64RowColKindBlockScaleScaleVecSizeF32F8f6f4typeF8f6f4typeF32Stype {
1651                spvariant,
1652                sync,
1653                aligned,
1654                m16n8k64,
1655                row,
1656                col,
1657                kind,
1658                block_scale,
1659                scale_vec_size,
1660                f32,
1661                f8f6f4type,
1662                f8f6f4type1,
1663                f322,
1664                stype,
1665                d,
1666                a,
1667                b,
1668                c,
1669                e,
1670                f,
1671                scale_a_data,
1672                byte_id_a,
1673                scale_b_data,
1674                byte_id_b,
1675            })
1676        }
1677    }
1678}
1679
1680pub mod section_5 {
1681    use super::*;
1682    use crate::r#type::instruction::mma_sp::section_5::*;
1683
1684    // ============================================================================
1685    // Generated enum parsers
1686    // ============================================================================
1687
1688    impl PtxParser for Atype {
1689        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1690            // Try U8
1691            {
1692                let saved_pos = stream.position();
1693                if stream.expect_string(".u8").is_ok() {
1694                    return Ok(Atype::U8);
1695                }
1696                stream.set_position(saved_pos);
1697            }
1698            let saved_pos = stream.position();
1699            // Try S8
1700            {
1701                let saved_pos = stream.position();
1702                if stream.expect_string(".s8").is_ok() {
1703                    return Ok(Atype::S8);
1704                }
1705                stream.set_position(saved_pos);
1706            }
1707            stream.set_position(saved_pos);
1708            let span = stream
1709                .peek()
1710                .map(|(_, s)| s.clone())
1711                .unwrap_or(Span { start: 0, end: 0 });
1712            let expected = &[".u8", ".s8"];
1713            let found = stream
1714                .peek()
1715                .map(|(t, _)| format!("{:?}", t))
1716                .unwrap_or_else(|_| "<end of input>".to_string());
1717            Err(crate::parser::unexpected_value(span, expected, found))
1718        }
1719    }
1720
1721    impl PtxParser for Btype {
1722        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1723            // Try U8
1724            {
1725                let saved_pos = stream.position();
1726                if stream.expect_string(".u8").is_ok() {
1727                    return Ok(Btype::U8);
1728                }
1729                stream.set_position(saved_pos);
1730            }
1731            let saved_pos = stream.position();
1732            // Try S8
1733            {
1734                let saved_pos = stream.position();
1735                if stream.expect_string(".s8").is_ok() {
1736                    return Ok(Btype::S8);
1737                }
1738                stream.set_position(saved_pos);
1739            }
1740            stream.set_position(saved_pos);
1741            let span = stream
1742                .peek()
1743                .map(|(_, s)| s.clone())
1744                .unwrap_or(Span { start: 0, end: 0 });
1745            let expected = &[".u8", ".s8"];
1746            let found = stream
1747                .peek()
1748                .map(|(t, _)| format!("{:?}", t))
1749                .unwrap_or_else(|_| "<end of input>".to_string());
1750            Err(crate::parser::unexpected_value(span, expected, found))
1751        }
1752    }
1753
1754    impl PtxParser for Shape {
1755        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1756            // Try M16n8k32
1757            {
1758                let saved_pos = stream.position();
1759                if stream.expect_string(".m16n8k32").is_ok() {
1760                    return Ok(Shape::M16n8k32);
1761                }
1762                stream.set_position(saved_pos);
1763            }
1764            let saved_pos = stream.position();
1765            // Try M16n8k64
1766            {
1767                let saved_pos = stream.position();
1768                if stream.expect_string(".m16n8k64").is_ok() {
1769                    return Ok(Shape::M16n8k64);
1770                }
1771                stream.set_position(saved_pos);
1772            }
1773            stream.set_position(saved_pos);
1774            let span = stream
1775                .peek()
1776                .map(|(_, s)| s.clone())
1777                .unwrap_or(Span { start: 0, end: 0 });
1778            let expected = &[".m16n8k32", ".m16n8k64"];
1779            let found = stream
1780                .peek()
1781                .map(|(t, _)| format!("{:?}", t))
1782                .unwrap_or_else(|_| "<end of input>".to_string());
1783            Err(crate::parser::unexpected_value(span, expected, found))
1784        }
1785    }
1786
1787    impl PtxParser for Spvariant {
1788        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1789            // Try SpOrderedMetadata
1790            {
1791                let saved_pos = stream.position();
1792                if stream.expect_string(".sp::ordered_metadata").is_ok() {
1793                    return Ok(Spvariant::SpOrderedMetadata);
1794                }
1795                stream.set_position(saved_pos);
1796            }
1797            let saved_pos = stream.position();
1798            // Try Sp
1799            {
1800                let saved_pos = stream.position();
1801                if stream.expect_string(".sp").is_ok() {
1802                    return Ok(Spvariant::Sp);
1803                }
1804                stream.set_position(saved_pos);
1805            }
1806            stream.set_position(saved_pos);
1807            let span = stream
1808                .peek()
1809                .map(|(_, s)| s.clone())
1810                .unwrap_or(Span { start: 0, end: 0 });
1811            let expected = &[".sp::ordered_metadata", ".sp"];
1812            let found = stream
1813                .peek()
1814                .map(|(t, _)| format!("{:?}", t))
1815                .unwrap_or_else(|_| "<end of input>".to_string());
1816            Err(crate::parser::unexpected_value(span, expected, found))
1817        }
1818    }
1819
1820    impl PtxParser for MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS32 {
1821        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1822            stream.expect_string("mma")?;
1823            let spvariant = Spvariant::parse(stream)?;
1824            stream.expect_complete()?;
1825            stream.expect_string(".sync")?;
1826            let sync = ();
1827            stream.expect_complete()?;
1828            stream.expect_string(".aligned")?;
1829            let aligned = ();
1830            stream.expect_complete()?;
1831            let shape = Shape::parse(stream)?;
1832            stream.expect_complete()?;
1833            stream.expect_string(".row")?;
1834            let row = ();
1835            stream.expect_complete()?;
1836            stream.expect_string(".col")?;
1837            let col = ();
1838            stream.expect_complete()?;
1839            let saved_pos = stream.position();
1840            let satfinite = stream.expect_string(".satfinite").is_ok();
1841            if !satfinite {
1842                stream.set_position(saved_pos);
1843            }
1844            stream.expect_complete()?;
1845            stream.expect_string(".s32")?;
1846            let s32 = ();
1847            stream.expect_complete()?;
1848            let atype = Atype::parse(stream)?;
1849            stream.expect_complete()?;
1850            let btype = Btype::parse(stream)?;
1851            stream.expect_complete()?;
1852            stream.expect_string(".s32")?;
1853            let s322 = ();
1854            stream.expect_complete()?;
1855            let d = GeneralOperand::parse(stream)?;
1856            stream.expect_complete()?;
1857            stream.expect(&PtxToken::Comma)?;
1858            let a = GeneralOperand::parse(stream)?;
1859            stream.expect_complete()?;
1860            stream.expect(&PtxToken::Comma)?;
1861            let b = GeneralOperand::parse(stream)?;
1862            stream.expect_complete()?;
1863            stream.expect(&PtxToken::Comma)?;
1864            let c = GeneralOperand::parse(stream)?;
1865            stream.expect_complete()?;
1866            stream.expect(&PtxToken::Comma)?;
1867            let e = GeneralOperand::parse(stream)?;
1868            stream.expect_complete()?;
1869            stream.expect(&PtxToken::Comma)?;
1870            let f = GeneralOperand::parse(stream)?;
1871            stream.expect_complete()?;
1872            stream.expect_complete()?;
1873            stream.expect(&PtxToken::Semicolon)?;
1874            Ok(
1875                MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS32 {
1876                    spvariant,
1877                    sync,
1878                    aligned,
1879                    shape,
1880                    row,
1881                    col,
1882                    satfinite,
1883                    s32,
1884                    atype,
1885                    btype,
1886                    s322,
1887                    d,
1888                    a,
1889                    b,
1890                    c,
1891                    e,
1892                    f,
1893                },
1894            )
1895        }
1896    }
1897}
1898
1899pub mod section_6 {
1900    use super::*;
1901    use crate::r#type::instruction::mma_sp::section_6::*;
1902
1903    // ============================================================================
1904    // Generated enum parsers
1905    // ============================================================================
1906
1907    impl PtxParser for Atype {
1908        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1909            // Try U4
1910            {
1911                let saved_pos = stream.position();
1912                if stream.expect_string(".u4").is_ok() {
1913                    return Ok(Atype::U4);
1914                }
1915                stream.set_position(saved_pos);
1916            }
1917            let saved_pos = stream.position();
1918            // Try S4
1919            {
1920                let saved_pos = stream.position();
1921                if stream.expect_string(".s4").is_ok() {
1922                    return Ok(Atype::S4);
1923                }
1924                stream.set_position(saved_pos);
1925            }
1926            stream.set_position(saved_pos);
1927            let span = stream
1928                .peek()
1929                .map(|(_, s)| s.clone())
1930                .unwrap_or(Span { start: 0, end: 0 });
1931            let expected = &[".u4", ".s4"];
1932            let found = stream
1933                .peek()
1934                .map(|(t, _)| format!("{:?}", t))
1935                .unwrap_or_else(|_| "<end of input>".to_string());
1936            Err(crate::parser::unexpected_value(span, expected, found))
1937        }
1938    }
1939
1940    impl PtxParser for Btype {
1941        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1942            // Try U4
1943            {
1944                let saved_pos = stream.position();
1945                if stream.expect_string(".u4").is_ok() {
1946                    return Ok(Btype::U4);
1947                }
1948                stream.set_position(saved_pos);
1949            }
1950            let saved_pos = stream.position();
1951            // Try S4
1952            {
1953                let saved_pos = stream.position();
1954                if stream.expect_string(".s4").is_ok() {
1955                    return Ok(Btype::S4);
1956                }
1957                stream.set_position(saved_pos);
1958            }
1959            stream.set_position(saved_pos);
1960            let span = stream
1961                .peek()
1962                .map(|(_, s)| s.clone())
1963                .unwrap_or(Span { start: 0, end: 0 });
1964            let expected = &[".u4", ".s4"];
1965            let found = stream
1966                .peek()
1967                .map(|(t, _)| format!("{:?}", t))
1968                .unwrap_or_else(|_| "<end of input>".to_string());
1969            Err(crate::parser::unexpected_value(span, expected, found))
1970        }
1971    }
1972
1973    impl PtxParser for Shape {
1974        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1975            // Try M16n8k128
1976            {
1977                let saved_pos = stream.position();
1978                if stream.expect_string(".m16n8k128").is_ok() {
1979                    return Ok(Shape::M16n8k128);
1980                }
1981                stream.set_position(saved_pos);
1982            }
1983            let saved_pos = stream.position();
1984            // Try M16n8k64
1985            {
1986                let saved_pos = stream.position();
1987                if stream.expect_string(".m16n8k64").is_ok() {
1988                    return Ok(Shape::M16n8k64);
1989                }
1990                stream.set_position(saved_pos);
1991            }
1992            stream.set_position(saved_pos);
1993            let span = stream
1994                .peek()
1995                .map(|(_, s)| s.clone())
1996                .unwrap_or(Span { start: 0, end: 0 });
1997            let expected = &[".m16n8k128", ".m16n8k64"];
1998            let found = stream
1999                .peek()
2000                .map(|(t, _)| format!("{:?}", t))
2001                .unwrap_or_else(|_| "<end of input>".to_string());
2002            Err(crate::parser::unexpected_value(span, expected, found))
2003        }
2004    }
2005
2006    impl PtxParser for Spvariant {
2007        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2008            // Try SpOrderedMetadata
2009            {
2010                let saved_pos = stream.position();
2011                if stream.expect_string(".sp::ordered_metadata").is_ok() {
2012                    return Ok(Spvariant::SpOrderedMetadata);
2013                }
2014                stream.set_position(saved_pos);
2015            }
2016            let saved_pos = stream.position();
2017            // Try Sp
2018            {
2019                let saved_pos = stream.position();
2020                if stream.expect_string(".sp").is_ok() {
2021                    return Ok(Spvariant::Sp);
2022                }
2023                stream.set_position(saved_pos);
2024            }
2025            stream.set_position(saved_pos);
2026            let span = stream
2027                .peek()
2028                .map(|(_, s)| s.clone())
2029                .unwrap_or(Span { start: 0, end: 0 });
2030            let expected = &[".sp::ordered_metadata", ".sp"];
2031            let found = stream
2032                .peek()
2033                .map(|(t, _)| format!("{:?}", t))
2034                .unwrap_or_else(|_| "<end of input>".to_string());
2035            Err(crate::parser::unexpected_value(span, expected, found))
2036        }
2037    }
2038
2039    impl PtxParser for MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS321 {
2040        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
2041            stream.expect_string("mma")?;
2042            let spvariant = Spvariant::parse(stream)?;
2043            stream.expect_complete()?;
2044            stream.expect_string(".sync")?;
2045            let sync = ();
2046            stream.expect_complete()?;
2047            stream.expect_string(".aligned")?;
2048            let aligned = ();
2049            stream.expect_complete()?;
2050            let shape = Shape::parse(stream)?;
2051            stream.expect_complete()?;
2052            stream.expect_string(".row")?;
2053            let row = ();
2054            stream.expect_complete()?;
2055            stream.expect_string(".col")?;
2056            let col = ();
2057            stream.expect_complete()?;
2058            let saved_pos = stream.position();
2059            let satfinite = stream.expect_string(".satfinite").is_ok();
2060            if !satfinite {
2061                stream.set_position(saved_pos);
2062            }
2063            stream.expect_complete()?;
2064            stream.expect_string(".s32")?;
2065            let s32 = ();
2066            stream.expect_complete()?;
2067            let atype = Atype::parse(stream)?;
2068            stream.expect_complete()?;
2069            let btype = Btype::parse(stream)?;
2070            stream.expect_complete()?;
2071            stream.expect_string(".s32")?;
2072            let s322 = ();
2073            stream.expect_complete()?;
2074            let d = GeneralOperand::parse(stream)?;
2075            stream.expect_complete()?;
2076            stream.expect(&PtxToken::Comma)?;
2077            let a = GeneralOperand::parse(stream)?;
2078            stream.expect_complete()?;
2079            stream.expect(&PtxToken::Comma)?;
2080            let b = GeneralOperand::parse(stream)?;
2081            stream.expect_complete()?;
2082            stream.expect(&PtxToken::Comma)?;
2083            let c = GeneralOperand::parse(stream)?;
2084            stream.expect_complete()?;
2085            stream.expect(&PtxToken::Comma)?;
2086            let e = GeneralOperand::parse(stream)?;
2087            stream.expect_complete()?;
2088            stream.expect(&PtxToken::Comma)?;
2089            let f = GeneralOperand::parse(stream)?;
2090            stream.expect_complete()?;
2091            stream.expect_complete()?;
2092            stream.expect(&PtxToken::Semicolon)?;
2093            Ok(
2094                MmaSpvariantSyncAlignedShapeRowColSatfiniteS32AtypeBtypeS321 {
2095                    spvariant,
2096                    sync,
2097                    aligned,
2098                    shape,
2099                    row,
2100                    col,
2101                    satfinite,
2102                    s32,
2103                    atype,
2104                    btype,
2105                    s322,
2106                    d,
2107                    a,
2108                    b,
2109                    c,
2110                    e,
2111                    f,
2112                },
2113            )
2114        }
2115    }
2116}
ptx_parser/parser/instruction/mma_sp.rs

ptx_parser/parser/instruction/
mma_sp.rs
