ptx_parser/parser/instruction/
wmma_store.rs

1//! Original PTX specification:
2//!
3//! wmma.store.d.sync.aligned.layout.shape{.ss}.type [p], r {, stride};
4//! .layout = {.row, .col};
5//! .shape  = {.m16n16k16, .m8n32k16, .m32n8k16};
6//! .ss     = {.global, .shared, .shared::cta};
7//! .type   = {.f16, .f32, .s32};
8//! ----------------------------------------------------------------
9//! wmma.store.d.sync.aligned.layout.shape{.ss}.type [p], r {, stride};
10//! .layout = {.row, .col};
11//! .shape  = {.m8n8k32, .m8n8k128};
12//! .ss     = {.global, .shared, .shared::cta};
13//! .type   = {.s32};
14//! ----------------------------------------------------------------
15//! wmma.store.d.sync.aligned.layout.shape{.ss}.type [p], r {, stride};
16//! .layout = {.row, .col};
17//! .shape  = {.m16n16k8};
18//! .ss     = {.global, .shared, .shared::cta};
19//! .type   = {.f32};
20//! ----------------------------------------------------------------
21//! wmma.store.d.sync.aligned.layout.shape{.ss}.type [p], r {, stride};
22//! .layout = {.row, .col};
23//! .shape  = {.m8n8k4 };
24//! .ss     = {.global, .shared, .shared::cta};
25//! .type   = {.f64};
26
27#![allow(unused)]
28
29use crate::lexer::PtxToken;
30use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
31use crate::r#type::common::*;
32
33pub mod section_0 {
34    use super::*;
35    use crate::r#type::instruction::wmma_store::section_0::*;
36
37    // ============================================================================
38    // Generated enum parsers
39    // ============================================================================
40
41    impl PtxParser for Layout {
42        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
43            // Try Row
44            {
45                let saved_pos = stream.position();
46                if stream.expect_string(".row").is_ok() {
47                    return Ok(Layout::Row);
48                }
49                stream.set_position(saved_pos);
50            }
51            let saved_pos = stream.position();
52            // Try Col
53            {
54                let saved_pos = stream.position();
55                if stream.expect_string(".col").is_ok() {
56                    return Ok(Layout::Col);
57                }
58                stream.set_position(saved_pos);
59            }
60            stream.set_position(saved_pos);
61            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
62            let expected = &[".row", ".col"];
63            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
64            Err(crate::parser::unexpected_value(span, expected, found))
65        }
66    }
67
68    impl PtxParser for Shape {
69        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
70            // Try M16n16k16
71            {
72                let saved_pos = stream.position();
73                if stream.expect_string(".m16n16k16").is_ok() {
74                    return Ok(Shape::M16n16k16);
75                }
76                stream.set_position(saved_pos);
77            }
78            let saved_pos = stream.position();
79            // Try M8n32k16
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".m8n32k16").is_ok() {
83                    return Ok(Shape::M8n32k16);
84                }
85                stream.set_position(saved_pos);
86            }
87            stream.set_position(saved_pos);
88            let saved_pos = stream.position();
89            // Try M32n8k16
90            {
91                let saved_pos = stream.position();
92                if stream.expect_string(".m32n8k16").is_ok() {
93                    return Ok(Shape::M32n8k16);
94                }
95                stream.set_position(saved_pos);
96            }
97            stream.set_position(saved_pos);
98            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
99            let expected = &[".m16n16k16", ".m8n32k16", ".m32n8k16"];
100            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
101            Err(crate::parser::unexpected_value(span, expected, found))
102        }
103    }
104
105    impl PtxParser for Ss {
106        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
107            // Try SharedCta
108            {
109                let saved_pos = stream.position();
110                if stream.expect_string(".shared::cta").is_ok() {
111                    return Ok(Ss::SharedCta);
112                }
113                stream.set_position(saved_pos);
114            }
115            let saved_pos = stream.position();
116            // Try Global
117            {
118                let saved_pos = stream.position();
119                if stream.expect_string(".global").is_ok() {
120                    return Ok(Ss::Global);
121                }
122                stream.set_position(saved_pos);
123            }
124            stream.set_position(saved_pos);
125            let saved_pos = stream.position();
126            // Try Shared
127            {
128                let saved_pos = stream.position();
129                if stream.expect_string(".shared").is_ok() {
130                    return Ok(Ss::Shared);
131                }
132                stream.set_position(saved_pos);
133            }
134            stream.set_position(saved_pos);
135            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
136            let expected = &[".shared::cta", ".global", ".shared"];
137            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
138            Err(crate::parser::unexpected_value(span, expected, found))
139        }
140    }
141
142    impl PtxParser for Type {
143        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
144            // Try F16
145            {
146                let saved_pos = stream.position();
147                if stream.expect_string(".f16").is_ok() {
148                    return Ok(Type::F16);
149                }
150                stream.set_position(saved_pos);
151            }
152            let saved_pos = stream.position();
153            // Try F32
154            {
155                let saved_pos = stream.position();
156                if stream.expect_string(".f32").is_ok() {
157                    return Ok(Type::F32);
158                }
159                stream.set_position(saved_pos);
160            }
161            stream.set_position(saved_pos);
162            let saved_pos = stream.position();
163            // Try S32
164            {
165                let saved_pos = stream.position();
166                if stream.expect_string(".s32").is_ok() {
167                    return Ok(Type::S32);
168                }
169                stream.set_position(saved_pos);
170            }
171            stream.set_position(saved_pos);
172            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
173            let expected = &[".f16", ".f32", ".s32"];
174            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
175            Err(crate::parser::unexpected_value(span, expected, found))
176        }
177    }
178
179    impl PtxParser for WmmaStoreDSyncAlignedLayoutShapeSsType {
180        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
181            stream.expect_string("wmma")?;
182            stream.expect_string(".store")?;
183            let store = ();
184            stream.expect_complete()?;
185            stream.expect_string(".d")?;
186            let d = ();
187            stream.expect_complete()?;
188            stream.expect_string(".sync")?;
189            let sync = ();
190            stream.expect_complete()?;
191            stream.expect_string(".aligned")?;
192            let aligned = ();
193            stream.expect_complete()?;
194            let layout = Layout::parse(stream)?;
195            stream.expect_complete()?;
196            let shape = Shape::parse(stream)?;
197            stream.expect_complete()?;
198            let saved_pos = stream.position();
199            let ss = match Ss::parse(stream) {
200                Ok(val) => Some(val),
201                Err(_) => {
202                    stream.set_position(saved_pos);
203                    None
204                }
205            };
206            stream.expect_complete()?;
207            let type_ = Type::parse(stream)?;
208            stream.expect_complete()?;
209            let p = AddressOperand::parse(stream)?;
210            stream.expect_complete()?;
211            stream.expect(&PtxToken::Comma)?;
212            let r = GeneralOperand::parse(stream)?;
213            stream.expect_complete()?;
214            let saved_pos = stream.position();
215            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
216            if !has_comma {
217                stream.set_position(saved_pos);
218            }
219            let saved_pos = stream.position();
220            let stride = match GeneralOperand::parse(stream) {
221                Ok(val) => Some(val),
222                Err(_) => {
223                    stream.set_position(saved_pos);
224                    None
225                }
226            };
227            stream.expect_complete()?;
228            stream.expect_complete()?;
229            stream.expect(&PtxToken::Semicolon)?;
230            Ok(WmmaStoreDSyncAlignedLayoutShapeSsType {
231                store,
232                d,
233                sync,
234                aligned,
235                layout,
236                shape,
237                ss,
238                type_,
239                p,
240                r,
241                stride,
242            })
243        }
244    }
245
246
247}
248
249pub mod section_1 {
250    use super::*;
251    use crate::r#type::instruction::wmma_store::section_1::*;
252
253    // ============================================================================
254    // Generated enum parsers
255    // ============================================================================
256
257    impl PtxParser for Layout {
258        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
259            // Try Row
260            {
261                let saved_pos = stream.position();
262                if stream.expect_string(".row").is_ok() {
263                    return Ok(Layout::Row);
264                }
265                stream.set_position(saved_pos);
266            }
267            let saved_pos = stream.position();
268            // Try Col
269            {
270                let saved_pos = stream.position();
271                if stream.expect_string(".col").is_ok() {
272                    return Ok(Layout::Col);
273                }
274                stream.set_position(saved_pos);
275            }
276            stream.set_position(saved_pos);
277            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
278            let expected = &[".row", ".col"];
279            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
280            Err(crate::parser::unexpected_value(span, expected, found))
281        }
282    }
283
284    impl PtxParser for Shape {
285        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
286            // Try M8n8k128
287            {
288                let saved_pos = stream.position();
289                if stream.expect_string(".m8n8k128").is_ok() {
290                    return Ok(Shape::M8n8k128);
291                }
292                stream.set_position(saved_pos);
293            }
294            let saved_pos = stream.position();
295            // Try M8n8k32
296            {
297                let saved_pos = stream.position();
298                if stream.expect_string(".m8n8k32").is_ok() {
299                    return Ok(Shape::M8n8k32);
300                }
301                stream.set_position(saved_pos);
302            }
303            stream.set_position(saved_pos);
304            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
305            let expected = &[".m8n8k128", ".m8n8k32"];
306            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
307            Err(crate::parser::unexpected_value(span, expected, found))
308        }
309    }
310
311    impl PtxParser for Ss {
312        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
313            // Try SharedCta
314            {
315                let saved_pos = stream.position();
316                if stream.expect_string(".shared::cta").is_ok() {
317                    return Ok(Ss::SharedCta);
318                }
319                stream.set_position(saved_pos);
320            }
321            let saved_pos = stream.position();
322            // Try Global
323            {
324                let saved_pos = stream.position();
325                if stream.expect_string(".global").is_ok() {
326                    return Ok(Ss::Global);
327                }
328                stream.set_position(saved_pos);
329            }
330            stream.set_position(saved_pos);
331            let saved_pos = stream.position();
332            // Try Shared
333            {
334                let saved_pos = stream.position();
335                if stream.expect_string(".shared").is_ok() {
336                    return Ok(Ss::Shared);
337                }
338                stream.set_position(saved_pos);
339            }
340            stream.set_position(saved_pos);
341            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
342            let expected = &[".shared::cta", ".global", ".shared"];
343            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
344            Err(crate::parser::unexpected_value(span, expected, found))
345        }
346    }
347
348    impl PtxParser for Type {
349        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
350            // Try S32
351            {
352                let saved_pos = stream.position();
353                if stream.expect_string(".s32").is_ok() {
354                    return Ok(Type::S32);
355                }
356                stream.set_position(saved_pos);
357            }
358            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
359            let expected = &[".s32"];
360            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
361            Err(crate::parser::unexpected_value(span, expected, found))
362        }
363    }
364
365    impl PtxParser for WmmaStoreDSyncAlignedLayoutShapeSsType1 {
366        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
367            stream.expect_string("wmma")?;
368            stream.expect_string(".store")?;
369            let store = ();
370            stream.expect_complete()?;
371            stream.expect_string(".d")?;
372            let d = ();
373            stream.expect_complete()?;
374            stream.expect_string(".sync")?;
375            let sync = ();
376            stream.expect_complete()?;
377            stream.expect_string(".aligned")?;
378            let aligned = ();
379            stream.expect_complete()?;
380            let layout = Layout::parse(stream)?;
381            stream.expect_complete()?;
382            let shape = Shape::parse(stream)?;
383            stream.expect_complete()?;
384            let saved_pos = stream.position();
385            let ss = match Ss::parse(stream) {
386                Ok(val) => Some(val),
387                Err(_) => {
388                    stream.set_position(saved_pos);
389                    None
390                }
391            };
392            stream.expect_complete()?;
393            let type_ = Type::parse(stream)?;
394            stream.expect_complete()?;
395            let p = AddressOperand::parse(stream)?;
396            stream.expect_complete()?;
397            stream.expect(&PtxToken::Comma)?;
398            let r = GeneralOperand::parse(stream)?;
399            stream.expect_complete()?;
400            let saved_pos = stream.position();
401            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
402            if !has_comma {
403                stream.set_position(saved_pos);
404            }
405            let saved_pos = stream.position();
406            let stride = match GeneralOperand::parse(stream) {
407                Ok(val) => Some(val),
408                Err(_) => {
409                    stream.set_position(saved_pos);
410                    None
411                }
412            };
413            stream.expect_complete()?;
414            stream.expect_complete()?;
415            stream.expect(&PtxToken::Semicolon)?;
416            Ok(WmmaStoreDSyncAlignedLayoutShapeSsType1 {
417                store,
418                d,
419                sync,
420                aligned,
421                layout,
422                shape,
423                ss,
424                type_,
425                p,
426                r,
427                stride,
428            })
429        }
430    }
431
432
433}
434
435pub mod section_2 {
436    use super::*;
437    use crate::r#type::instruction::wmma_store::section_2::*;
438
439    // ============================================================================
440    // Generated enum parsers
441    // ============================================================================
442
443    impl PtxParser for Layout {
444        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
445            // Try Row
446            {
447                let saved_pos = stream.position();
448                if stream.expect_string(".row").is_ok() {
449                    return Ok(Layout::Row);
450                }
451                stream.set_position(saved_pos);
452            }
453            let saved_pos = stream.position();
454            // Try Col
455            {
456                let saved_pos = stream.position();
457                if stream.expect_string(".col").is_ok() {
458                    return Ok(Layout::Col);
459                }
460                stream.set_position(saved_pos);
461            }
462            stream.set_position(saved_pos);
463            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
464            let expected = &[".row", ".col"];
465            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
466            Err(crate::parser::unexpected_value(span, expected, found))
467        }
468    }
469
470    impl PtxParser for Shape {
471        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
472            // Try M16n16k8
473            {
474                let saved_pos = stream.position();
475                if stream.expect_string(".m16n16k8").is_ok() {
476                    return Ok(Shape::M16n16k8);
477                }
478                stream.set_position(saved_pos);
479            }
480            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
481            let expected = &[".m16n16k8"];
482            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
483            Err(crate::parser::unexpected_value(span, expected, found))
484        }
485    }
486
487    impl PtxParser for Ss {
488        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
489            // Try SharedCta
490            {
491                let saved_pos = stream.position();
492                if stream.expect_string(".shared::cta").is_ok() {
493                    return Ok(Ss::SharedCta);
494                }
495                stream.set_position(saved_pos);
496            }
497            let saved_pos = stream.position();
498            // Try Global
499            {
500                let saved_pos = stream.position();
501                if stream.expect_string(".global").is_ok() {
502                    return Ok(Ss::Global);
503                }
504                stream.set_position(saved_pos);
505            }
506            stream.set_position(saved_pos);
507            let saved_pos = stream.position();
508            // Try Shared
509            {
510                let saved_pos = stream.position();
511                if stream.expect_string(".shared").is_ok() {
512                    return Ok(Ss::Shared);
513                }
514                stream.set_position(saved_pos);
515            }
516            stream.set_position(saved_pos);
517            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
518            let expected = &[".shared::cta", ".global", ".shared"];
519            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
520            Err(crate::parser::unexpected_value(span, expected, found))
521        }
522    }
523
524    impl PtxParser for Type {
525        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
526            // Try F32
527            {
528                let saved_pos = stream.position();
529                if stream.expect_string(".f32").is_ok() {
530                    return Ok(Type::F32);
531                }
532                stream.set_position(saved_pos);
533            }
534            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
535            let expected = &[".f32"];
536            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
537            Err(crate::parser::unexpected_value(span, expected, found))
538        }
539    }
540
541    impl PtxParser for WmmaStoreDSyncAlignedLayoutShapeSsType2 {
542        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
543            stream.expect_string("wmma")?;
544            stream.expect_string(".store")?;
545            let store = ();
546            stream.expect_complete()?;
547            stream.expect_string(".d")?;
548            let d = ();
549            stream.expect_complete()?;
550            stream.expect_string(".sync")?;
551            let sync = ();
552            stream.expect_complete()?;
553            stream.expect_string(".aligned")?;
554            let aligned = ();
555            stream.expect_complete()?;
556            let layout = Layout::parse(stream)?;
557            stream.expect_complete()?;
558            let shape = Shape::parse(stream)?;
559            stream.expect_complete()?;
560            let saved_pos = stream.position();
561            let ss = match Ss::parse(stream) {
562                Ok(val) => Some(val),
563                Err(_) => {
564                    stream.set_position(saved_pos);
565                    None
566                }
567            };
568            stream.expect_complete()?;
569            let type_ = Type::parse(stream)?;
570            stream.expect_complete()?;
571            let p = AddressOperand::parse(stream)?;
572            stream.expect_complete()?;
573            stream.expect(&PtxToken::Comma)?;
574            let r = GeneralOperand::parse(stream)?;
575            stream.expect_complete()?;
576            let saved_pos = stream.position();
577            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
578            if !has_comma {
579                stream.set_position(saved_pos);
580            }
581            let saved_pos = stream.position();
582            let stride = match GeneralOperand::parse(stream) {
583                Ok(val) => Some(val),
584                Err(_) => {
585                    stream.set_position(saved_pos);
586                    None
587                }
588            };
589            stream.expect_complete()?;
590            stream.expect_complete()?;
591            stream.expect(&PtxToken::Semicolon)?;
592            Ok(WmmaStoreDSyncAlignedLayoutShapeSsType2 {
593                store,
594                d,
595                sync,
596                aligned,
597                layout,
598                shape,
599                ss,
600                type_,
601                p,
602                r,
603                stride,
604            })
605        }
606    }
607
608
609}
610
611pub mod section_3 {
612    use super::*;
613    use crate::r#type::instruction::wmma_store::section_3::*;
614
615    // ============================================================================
616    // Generated enum parsers
617    // ============================================================================
618
619    impl PtxParser for Layout {
620        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
621            // Try Row
622            {
623                let saved_pos = stream.position();
624                if stream.expect_string(".row").is_ok() {
625                    return Ok(Layout::Row);
626                }
627                stream.set_position(saved_pos);
628            }
629            let saved_pos = stream.position();
630            // Try Col
631            {
632                let saved_pos = stream.position();
633                if stream.expect_string(".col").is_ok() {
634                    return Ok(Layout::Col);
635                }
636                stream.set_position(saved_pos);
637            }
638            stream.set_position(saved_pos);
639            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
640            let expected = &[".row", ".col"];
641            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
642            Err(crate::parser::unexpected_value(span, expected, found))
643        }
644    }
645
646    impl PtxParser for Shape {
647        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
648            // Try M8n8k4
649            {
650                let saved_pos = stream.position();
651                if stream.expect_string(".m8n8k4").is_ok() {
652                    return Ok(Shape::M8n8k4);
653                }
654                stream.set_position(saved_pos);
655            }
656            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
657            let expected = &[".m8n8k4"];
658            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
659            Err(crate::parser::unexpected_value(span, expected, found))
660        }
661    }
662
663    impl PtxParser for Ss {
664        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
665            // Try SharedCta
666            {
667                let saved_pos = stream.position();
668                if stream.expect_string(".shared::cta").is_ok() {
669                    return Ok(Ss::SharedCta);
670                }
671                stream.set_position(saved_pos);
672            }
673            let saved_pos = stream.position();
674            // Try Global
675            {
676                let saved_pos = stream.position();
677                if stream.expect_string(".global").is_ok() {
678                    return Ok(Ss::Global);
679                }
680                stream.set_position(saved_pos);
681            }
682            stream.set_position(saved_pos);
683            let saved_pos = stream.position();
684            // Try Shared
685            {
686                let saved_pos = stream.position();
687                if stream.expect_string(".shared").is_ok() {
688                    return Ok(Ss::Shared);
689                }
690                stream.set_position(saved_pos);
691            }
692            stream.set_position(saved_pos);
693            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
694            let expected = &[".shared::cta", ".global", ".shared"];
695            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
696            Err(crate::parser::unexpected_value(span, expected, found))
697        }
698    }
699
700    impl PtxParser for Type {
701        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
702            // Try F64
703            {
704                let saved_pos = stream.position();
705                if stream.expect_string(".f64").is_ok() {
706                    return Ok(Type::F64);
707                }
708                stream.set_position(saved_pos);
709            }
710            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
711            let expected = &[".f64"];
712            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
713            Err(crate::parser::unexpected_value(span, expected, found))
714        }
715    }
716
717    impl PtxParser for WmmaStoreDSyncAlignedLayoutShapeSsType3 {
718        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
719            stream.expect_string("wmma")?;
720            stream.expect_string(".store")?;
721            let store = ();
722            stream.expect_complete()?;
723            stream.expect_string(".d")?;
724            let d = ();
725            stream.expect_complete()?;
726            stream.expect_string(".sync")?;
727            let sync = ();
728            stream.expect_complete()?;
729            stream.expect_string(".aligned")?;
730            let aligned = ();
731            stream.expect_complete()?;
732            let layout = Layout::parse(stream)?;
733            stream.expect_complete()?;
734            let shape = Shape::parse(stream)?;
735            stream.expect_complete()?;
736            let saved_pos = stream.position();
737            let ss = match Ss::parse(stream) {
738                Ok(val) => Some(val),
739                Err(_) => {
740                    stream.set_position(saved_pos);
741                    None
742                }
743            };
744            stream.expect_complete()?;
745            let type_ = Type::parse(stream)?;
746            stream.expect_complete()?;
747            let p = AddressOperand::parse(stream)?;
748            stream.expect_complete()?;
749            stream.expect(&PtxToken::Comma)?;
750            let r = GeneralOperand::parse(stream)?;
751            stream.expect_complete()?;
752            let saved_pos = stream.position();
753            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
754            if !has_comma {
755                stream.set_position(saved_pos);
756            }
757            let saved_pos = stream.position();
758            let stride = match GeneralOperand::parse(stream) {
759                Ok(val) => Some(val),
760                Err(_) => {
761                    stream.set_position(saved_pos);
762                    None
763                }
764            };
765            stream.expect_complete()?;
766            stream.expect_complete()?;
767            stream.expect(&PtxToken::Semicolon)?;
768            Ok(WmmaStoreDSyncAlignedLayoutShapeSsType3 {
769                store,
770                d,
771                sync,
772                aligned,
773                layout,
774                shape,
775                ss,
776                type_,
777                p,
778                r,
779                stride,
780            })
781        }
782    }
783
784
785}
786
ptx_parser/parser/instruction/wmma_store.rs

ptx_parser/parser/instruction/
wmma_store.rs
