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

ptx_parser/parser/instruction/
mma_sp.rs
