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

ptx_parser/parser/instruction/
wmma_store.rs
