ptx_parser/parser/instruction/
st.rs

1//! Original PTX specification:
2//!
3//! st{.weak}{.ss}{.cop}{.level::cache_hint}{.vec}.type   [a], b{, cache-policy};
4//! st{.weak}{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
5//! st.volatile{.ss}{.vec}.type                           [a], b;
6//! st.relaxed.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
7//! st.release.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
8//! st.mmio.relaxed.sys{.global}.type         [a], b;
9//! .ss =                       { .global, .local, .param, .param::func, .shared, .shared::cta, .shared::cluster};
10//! .level1::eviction_priority = { .L1::evict_normal, .L1::evict_unchanged,
11//! .L1::evict_first, .L1::evict_last, .L1::no_allocate };
12//! .level2::eviction_priority = { .L2::evict_normal, .L2::evict_first, .L2::evict_last };
13//! .level::cache_hint =        { .L2::cache_hint };
14//! .cop =                      { .wb, .cg, .cs, .wt };
15//! .sem =                      { .relaxed, .release };
16//! .scope =                    { .cta, .cluster, .gpu, .sys };
17//! .vec =                      { .v2, .v4, .v8 };
18//! .type =                     { .b8, .b16, .b32, .b64, .b128,
19//! .u8, .u16, .u32, .u64,
20//! .s8, .s16, .s32, .s64,
21//! .f32, .f64 };
22
23#![allow(unused)]
24
25use crate::lexer::PtxToken;
26use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
27use crate::r#type::common::*;
28
29pub mod section_0 {
30    use super::*;
31    use crate::r#type::instruction::st::section_0::*;
32
33    // ============================================================================
34    // Generated enum parsers
35    // ============================================================================
36
37    impl PtxParser for Cop {
38        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
39            // Try Wb
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".wb").is_ok() {
43                    return Ok(Cop::Wb);
44                }
45                stream.set_position(saved_pos);
46            }
47            let saved_pos = stream.position();
48            // Try Cg
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".cg").is_ok() {
52                    return Ok(Cop::Cg);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try Cs
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".cs").is_ok() {
62                    return Ok(Cop::Cs);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let saved_pos = stream.position();
68            // Try Wt
69            {
70                let saved_pos = stream.position();
71                if stream.expect_string(".wt").is_ok() {
72                    return Ok(Cop::Wt);
73                }
74                stream.set_position(saved_pos);
75            }
76            stream.set_position(saved_pos);
77            let span = stream
78                .peek()
79                .map(|(_, s)| s.clone())
80                .unwrap_or(Span { start: 0, end: 0 });
81            let expected = &[".wb", ".cg", ".cs", ".wt"];
82            let found = stream
83                .peek()
84                .map(|(t, _)| format!("{:?}", t))
85                .unwrap_or_else(|_| "<end of input>".to_string());
86            Err(crate::parser::unexpected_value(span, expected, found))
87        }
88    }
89
90    impl PtxParser for Level1EvictionPriority {
91        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
92            // Try L1EvictUnchanged
93            {
94                let saved_pos = stream.position();
95                if stream.expect_string(".L1::evict_unchanged").is_ok() {
96                    return Ok(Level1EvictionPriority::L1EvictUnchanged);
97                }
98                stream.set_position(saved_pos);
99            }
100            let saved_pos = stream.position();
101            // Try L1EvictNormal
102            {
103                let saved_pos = stream.position();
104                if stream.expect_string(".L1::evict_normal").is_ok() {
105                    return Ok(Level1EvictionPriority::L1EvictNormal);
106                }
107                stream.set_position(saved_pos);
108            }
109            stream.set_position(saved_pos);
110            let saved_pos = stream.position();
111            // Try L1EvictFirst
112            {
113                let saved_pos = stream.position();
114                if stream.expect_string(".L1::evict_first").is_ok() {
115                    return Ok(Level1EvictionPriority::L1EvictFirst);
116                }
117                stream.set_position(saved_pos);
118            }
119            stream.set_position(saved_pos);
120            let saved_pos = stream.position();
121            // Try L1NoAllocate
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".L1::no_allocate").is_ok() {
125                    return Ok(Level1EvictionPriority::L1NoAllocate);
126                }
127                stream.set_position(saved_pos);
128            }
129            stream.set_position(saved_pos);
130            let saved_pos = stream.position();
131            // Try L1EvictLast
132            {
133                let saved_pos = stream.position();
134                if stream.expect_string(".L1::evict_last").is_ok() {
135                    return Ok(Level1EvictionPriority::L1EvictLast);
136                }
137                stream.set_position(saved_pos);
138            }
139            stream.set_position(saved_pos);
140            let span = stream
141                .peek()
142                .map(|(_, s)| s.clone())
143                .unwrap_or(Span { start: 0, end: 0 });
144            let expected = &[
145                ".L1::evict_unchanged",
146                ".L1::evict_normal",
147                ".L1::evict_first",
148                ".L1::no_allocate",
149                ".L1::evict_last",
150            ];
151            let found = stream
152                .peek()
153                .map(|(t, _)| format!("{:?}", t))
154                .unwrap_or_else(|_| "<end of input>".to_string());
155            Err(crate::parser::unexpected_value(span, expected, found))
156        }
157    }
158
159    impl PtxParser for Level2EvictionPriority {
160        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
161            // Try L2EvictNormal
162            {
163                let saved_pos = stream.position();
164                if stream.expect_string(".L2::evict_normal").is_ok() {
165                    return Ok(Level2EvictionPriority::L2EvictNormal);
166                }
167                stream.set_position(saved_pos);
168            }
169            let saved_pos = stream.position();
170            // Try L2EvictFirst
171            {
172                let saved_pos = stream.position();
173                if stream.expect_string(".L2::evict_first").is_ok() {
174                    return Ok(Level2EvictionPriority::L2EvictFirst);
175                }
176                stream.set_position(saved_pos);
177            }
178            stream.set_position(saved_pos);
179            let saved_pos = stream.position();
180            // Try L2EvictLast
181            {
182                let saved_pos = stream.position();
183                if stream.expect_string(".L2::evict_last").is_ok() {
184                    return Ok(Level2EvictionPriority::L2EvictLast);
185                }
186                stream.set_position(saved_pos);
187            }
188            stream.set_position(saved_pos);
189            let span = stream
190                .peek()
191                .map(|(_, s)| s.clone())
192                .unwrap_or(Span { start: 0, end: 0 });
193            let expected = &[".L2::evict_normal", ".L2::evict_first", ".L2::evict_last"];
194            let found = stream
195                .peek()
196                .map(|(t, _)| format!("{:?}", t))
197                .unwrap_or_else(|_| "<end of input>".to_string());
198            Err(crate::parser::unexpected_value(span, expected, found))
199        }
200    }
201
202    impl PtxParser for LevelCacheHint {
203        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
204            // Try L2CacheHint
205            {
206                let saved_pos = stream.position();
207                if stream.expect_string(".L2::cache_hint").is_ok() {
208                    return Ok(LevelCacheHint::L2CacheHint);
209                }
210                stream.set_position(saved_pos);
211            }
212            let span = stream
213                .peek()
214                .map(|(_, s)| s.clone())
215                .unwrap_or(Span { start: 0, end: 0 });
216            let expected = &[".L2::cache_hint"];
217            let found = stream
218                .peek()
219                .map(|(t, _)| format!("{:?}", t))
220                .unwrap_or_else(|_| "<end of input>".to_string());
221            Err(crate::parser::unexpected_value(span, expected, found))
222        }
223    }
224
225    impl PtxParser for Scope {
226        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
227            // Try Cluster
228            {
229                let saved_pos = stream.position();
230                if stream.expect_string(".cluster").is_ok() {
231                    return Ok(Scope::Cluster);
232                }
233                stream.set_position(saved_pos);
234            }
235            let saved_pos = stream.position();
236            // Try Cta
237            {
238                let saved_pos = stream.position();
239                if stream.expect_string(".cta").is_ok() {
240                    return Ok(Scope::Cta);
241                }
242                stream.set_position(saved_pos);
243            }
244            stream.set_position(saved_pos);
245            let saved_pos = stream.position();
246            // Try Gpu
247            {
248                let saved_pos = stream.position();
249                if stream.expect_string(".gpu").is_ok() {
250                    return Ok(Scope::Gpu);
251                }
252                stream.set_position(saved_pos);
253            }
254            stream.set_position(saved_pos);
255            let saved_pos = stream.position();
256            // Try Sys
257            {
258                let saved_pos = stream.position();
259                if stream.expect_string(".sys").is_ok() {
260                    return Ok(Scope::Sys);
261                }
262                stream.set_position(saved_pos);
263            }
264            stream.set_position(saved_pos);
265            let span = stream
266                .peek()
267                .map(|(_, s)| s.clone())
268                .unwrap_or(Span { start: 0, end: 0 });
269            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
270            let found = stream
271                .peek()
272                .map(|(t, _)| format!("{:?}", t))
273                .unwrap_or_else(|_| "<end of input>".to_string());
274            Err(crate::parser::unexpected_value(span, expected, found))
275        }
276    }
277
278    impl PtxParser for Ss {
279        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
280            // Try SharedCluster
281            {
282                let saved_pos = stream.position();
283                if stream.expect_string(".shared::cluster").is_ok() {
284                    return Ok(Ss::SharedCluster);
285                }
286                stream.set_position(saved_pos);
287            }
288            let saved_pos = stream.position();
289            // Try ParamFunc
290            {
291                let saved_pos = stream.position();
292                if stream.expect_string(".param::func").is_ok() {
293                    return Ok(Ss::ParamFunc);
294                }
295                stream.set_position(saved_pos);
296            }
297            stream.set_position(saved_pos);
298            let saved_pos = stream.position();
299            // Try SharedCta
300            {
301                let saved_pos = stream.position();
302                if stream.expect_string(".shared::cta").is_ok() {
303                    return Ok(Ss::SharedCta);
304                }
305                stream.set_position(saved_pos);
306            }
307            stream.set_position(saved_pos);
308            let saved_pos = stream.position();
309            // Try Global
310            {
311                let saved_pos = stream.position();
312                if stream.expect_string(".global").is_ok() {
313                    return Ok(Ss::Global);
314                }
315                stream.set_position(saved_pos);
316            }
317            stream.set_position(saved_pos);
318            let saved_pos = stream.position();
319            // Try Shared
320            {
321                let saved_pos = stream.position();
322                if stream.expect_string(".shared").is_ok() {
323                    return Ok(Ss::Shared);
324                }
325                stream.set_position(saved_pos);
326            }
327            stream.set_position(saved_pos);
328            let saved_pos = stream.position();
329            // Try Local
330            {
331                let saved_pos = stream.position();
332                if stream.expect_string(".local").is_ok() {
333                    return Ok(Ss::Local);
334                }
335                stream.set_position(saved_pos);
336            }
337            stream.set_position(saved_pos);
338            let saved_pos = stream.position();
339            // Try Param
340            {
341                let saved_pos = stream.position();
342                if stream.expect_string(".param").is_ok() {
343                    return Ok(Ss::Param);
344                }
345                stream.set_position(saved_pos);
346            }
347            stream.set_position(saved_pos);
348            let span = stream
349                .peek()
350                .map(|(_, s)| s.clone())
351                .unwrap_or(Span { start: 0, end: 0 });
352            let expected = &[
353                ".shared::cluster",
354                ".param::func",
355                ".shared::cta",
356                ".global",
357                ".shared",
358                ".local",
359                ".param",
360            ];
361            let found = stream
362                .peek()
363                .map(|(t, _)| format!("{:?}", t))
364                .unwrap_or_else(|_| "<end of input>".to_string());
365            Err(crate::parser::unexpected_value(span, expected, found))
366        }
367    }
368
369    impl PtxParser for Type {
370        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
371            // Try B128
372            {
373                let saved_pos = stream.position();
374                if stream.expect_string(".b128").is_ok() {
375                    return Ok(Type::B128);
376                }
377                stream.set_position(saved_pos);
378            }
379            let saved_pos = stream.position();
380            // Try B16
381            {
382                let saved_pos = stream.position();
383                if stream.expect_string(".b16").is_ok() {
384                    return Ok(Type::B16);
385                }
386                stream.set_position(saved_pos);
387            }
388            stream.set_position(saved_pos);
389            let saved_pos = stream.position();
390            // Try B32
391            {
392                let saved_pos = stream.position();
393                if stream.expect_string(".b32").is_ok() {
394                    return Ok(Type::B32);
395                }
396                stream.set_position(saved_pos);
397            }
398            stream.set_position(saved_pos);
399            let saved_pos = stream.position();
400            // Try B64
401            {
402                let saved_pos = stream.position();
403                if stream.expect_string(".b64").is_ok() {
404                    return Ok(Type::B64);
405                }
406                stream.set_position(saved_pos);
407            }
408            stream.set_position(saved_pos);
409            let saved_pos = stream.position();
410            // Try U16
411            {
412                let saved_pos = stream.position();
413                if stream.expect_string(".u16").is_ok() {
414                    return Ok(Type::U16);
415                }
416                stream.set_position(saved_pos);
417            }
418            stream.set_position(saved_pos);
419            let saved_pos = stream.position();
420            // Try U32
421            {
422                let saved_pos = stream.position();
423                if stream.expect_string(".u32").is_ok() {
424                    return Ok(Type::U32);
425                }
426                stream.set_position(saved_pos);
427            }
428            stream.set_position(saved_pos);
429            let saved_pos = stream.position();
430            // Try U64
431            {
432                let saved_pos = stream.position();
433                if stream.expect_string(".u64").is_ok() {
434                    return Ok(Type::U64);
435                }
436                stream.set_position(saved_pos);
437            }
438            stream.set_position(saved_pos);
439            let saved_pos = stream.position();
440            // Try S16
441            {
442                let saved_pos = stream.position();
443                if stream.expect_string(".s16").is_ok() {
444                    return Ok(Type::S16);
445                }
446                stream.set_position(saved_pos);
447            }
448            stream.set_position(saved_pos);
449            let saved_pos = stream.position();
450            // Try S32
451            {
452                let saved_pos = stream.position();
453                if stream.expect_string(".s32").is_ok() {
454                    return Ok(Type::S32);
455                }
456                stream.set_position(saved_pos);
457            }
458            stream.set_position(saved_pos);
459            let saved_pos = stream.position();
460            // Try S64
461            {
462                let saved_pos = stream.position();
463                if stream.expect_string(".s64").is_ok() {
464                    return Ok(Type::S64);
465                }
466                stream.set_position(saved_pos);
467            }
468            stream.set_position(saved_pos);
469            let saved_pos = stream.position();
470            // Try F32
471            {
472                let saved_pos = stream.position();
473                if stream.expect_string(".f32").is_ok() {
474                    return Ok(Type::F32);
475                }
476                stream.set_position(saved_pos);
477            }
478            stream.set_position(saved_pos);
479            let saved_pos = stream.position();
480            // Try F64
481            {
482                let saved_pos = stream.position();
483                if stream.expect_string(".f64").is_ok() {
484                    return Ok(Type::F64);
485                }
486                stream.set_position(saved_pos);
487            }
488            stream.set_position(saved_pos);
489            let saved_pos = stream.position();
490            // Try B8
491            {
492                let saved_pos = stream.position();
493                if stream.expect_string(".b8").is_ok() {
494                    return Ok(Type::B8);
495                }
496                stream.set_position(saved_pos);
497            }
498            stream.set_position(saved_pos);
499            let saved_pos = stream.position();
500            // Try U8
501            {
502                let saved_pos = stream.position();
503                if stream.expect_string(".u8").is_ok() {
504                    return Ok(Type::U8);
505                }
506                stream.set_position(saved_pos);
507            }
508            stream.set_position(saved_pos);
509            let saved_pos = stream.position();
510            // Try S8
511            {
512                let saved_pos = stream.position();
513                if stream.expect_string(".s8").is_ok() {
514                    return Ok(Type::S8);
515                }
516                stream.set_position(saved_pos);
517            }
518            stream.set_position(saved_pos);
519            let span = stream
520                .peek()
521                .map(|(_, s)| s.clone())
522                .unwrap_or(Span { start: 0, end: 0 });
523            let expected = &[
524                ".b128", ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64",
525                ".f32", ".f64", ".b8", ".u8", ".s8",
526            ];
527            let found = stream
528                .peek()
529                .map(|(t, _)| format!("{:?}", t))
530                .unwrap_or_else(|_| "<end of input>".to_string());
531            Err(crate::parser::unexpected_value(span, expected, found))
532        }
533    }
534
535    impl PtxParser for Vec {
536        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
537            // Try V2
538            {
539                let saved_pos = stream.position();
540                if stream.expect_string(".v2").is_ok() {
541                    return Ok(Vec::V2);
542                }
543                stream.set_position(saved_pos);
544            }
545            let saved_pos = stream.position();
546            // Try V4
547            {
548                let saved_pos = stream.position();
549                if stream.expect_string(".v4").is_ok() {
550                    return Ok(Vec::V4);
551                }
552                stream.set_position(saved_pos);
553            }
554            stream.set_position(saved_pos);
555            let saved_pos = stream.position();
556            // Try V8
557            {
558                let saved_pos = stream.position();
559                if stream.expect_string(".v8").is_ok() {
560                    return Ok(Vec::V8);
561                }
562                stream.set_position(saved_pos);
563            }
564            stream.set_position(saved_pos);
565            let span = stream
566                .peek()
567                .map(|(_, s)| s.clone())
568                .unwrap_or(Span { start: 0, end: 0 });
569            let expected = &[".v2", ".v4", ".v8"];
570            let found = stream
571                .peek()
572                .map(|(t, _)| format!("{:?}", t))
573                .unwrap_or_else(|_| "<end of input>".to_string());
574            Err(crate::parser::unexpected_value(span, expected, found))
575        }
576    }
577
578    impl PtxParser for StWeakSsCopLevelCacheHintVecType {
579        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
580            stream.expect_string("st")?;
581            let saved_pos = stream.position();
582            let weak = stream.expect_string(".weak").is_ok();
583            if !weak {
584                stream.set_position(saved_pos);
585            }
586            stream.expect_complete()?;
587            let saved_pos = stream.position();
588            let ss = match Ss::parse(stream) {
589                Ok(val) => Some(val),
590                Err(_) => {
591                    stream.set_position(saved_pos);
592                    None
593                }
594            };
595            stream.expect_complete()?;
596            let saved_pos = stream.position();
597            let cop = match Cop::parse(stream) {
598                Ok(val) => Some(val),
599                Err(_) => {
600                    stream.set_position(saved_pos);
601                    None
602                }
603            };
604            stream.expect_complete()?;
605            let saved_pos = stream.position();
606            let level_cache_hint = match LevelCacheHint::parse(stream) {
607                Ok(val) => Some(val),
608                Err(_) => {
609                    stream.set_position(saved_pos);
610                    None
611                }
612            };
613            stream.expect_complete()?;
614            let saved_pos = stream.position();
615            let vec = match Vec::parse(stream) {
616                Ok(val) => Some(val),
617                Err(_) => {
618                    stream.set_position(saved_pos);
619                    None
620                }
621            };
622            stream.expect_complete()?;
623            let type_ = Type::parse(stream)?;
624            stream.expect_complete()?;
625            let a = AddressOperand::parse(stream)?;
626            stream.expect_complete()?;
627            stream.expect(&PtxToken::Comma)?;
628            let b = GeneralOperand::parse(stream)?;
629            stream.expect_complete()?;
630            let saved_pos = stream.position();
631            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
632            if !has_comma {
633                stream.set_position(saved_pos);
634            }
635            let saved_pos = stream.position();
636            let cache_policy = match GeneralOperand::parse(stream) {
637                Ok(val) => Some(val),
638                Err(_) => {
639                    stream.set_position(saved_pos);
640                    None
641                }
642            };
643            stream.expect_complete()?;
644            stream.expect_complete()?;
645            stream.expect(&PtxToken::Semicolon)?;
646            Ok(StWeakSsCopLevelCacheHintVecType {
647                weak,
648                ss,
649                cop,
650                level_cache_hint,
651                vec,
652                type_,
653                a,
654                b,
655                cache_policy,
656            })
657        }
658    }
659
660    impl PtxParser for StWeakSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType {
661        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
662            stream.expect_string("st")?;
663            let saved_pos = stream.position();
664            let weak = stream.expect_string(".weak").is_ok();
665            if !weak {
666                stream.set_position(saved_pos);
667            }
668            stream.expect_complete()?;
669            let saved_pos = stream.position();
670            let ss = match Ss::parse(stream) {
671                Ok(val) => Some(val),
672                Err(_) => {
673                    stream.set_position(saved_pos);
674                    None
675                }
676            };
677            stream.expect_complete()?;
678            let saved_pos = stream.position();
679            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
680                Ok(val) => Some(val),
681                Err(_) => {
682                    stream.set_position(saved_pos);
683                    None
684                }
685            };
686            stream.expect_complete()?;
687            let saved_pos = stream.position();
688            let level2_eviction_priority = match Level2EvictionPriority::parse(stream) {
689                Ok(val) => Some(val),
690                Err(_) => {
691                    stream.set_position(saved_pos);
692                    None
693                }
694            };
695            stream.expect_complete()?;
696            let saved_pos = stream.position();
697            let level_cache_hint = match LevelCacheHint::parse(stream) {
698                Ok(val) => Some(val),
699                Err(_) => {
700                    stream.set_position(saved_pos);
701                    None
702                }
703            };
704            stream.expect_complete()?;
705            let saved_pos = stream.position();
706            let vec = match Vec::parse(stream) {
707                Ok(val) => Some(val),
708                Err(_) => {
709                    stream.set_position(saved_pos);
710                    None
711                }
712            };
713            stream.expect_complete()?;
714            let type_ = Type::parse(stream)?;
715            stream.expect_complete()?;
716            let a = AddressOperand::parse(stream)?;
717            stream.expect_complete()?;
718            stream.expect(&PtxToken::Comma)?;
719            let b = GeneralOperand::parse(stream)?;
720            stream.expect_complete()?;
721            let saved_pos = stream.position();
722            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
723            if !has_comma {
724                stream.set_position(saved_pos);
725            }
726            let saved_pos = stream.position();
727            let cache_policy = match GeneralOperand::parse(stream) {
728                Ok(val) => Some(val),
729                Err(_) => {
730                    stream.set_position(saved_pos);
731                    None
732                }
733            };
734            stream.expect_complete()?;
735            stream.expect_complete()?;
736            stream.expect(&PtxToken::Semicolon)?;
737            Ok(
738                StWeakSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType {
739                    weak,
740                    ss,
741                    level1_eviction_priority,
742                    level2_eviction_priority,
743                    level_cache_hint,
744                    vec,
745                    type_,
746                    a,
747                    b,
748                    cache_policy,
749                },
750            )
751        }
752    }
753
754    impl PtxParser for StVolatileSsVecType {
755        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
756            stream.expect_string("st")?;
757            stream.expect_string(".volatile")?;
758            let volatile = ();
759            stream.expect_complete()?;
760            let saved_pos = stream.position();
761            let ss = match Ss::parse(stream) {
762                Ok(val) => Some(val),
763                Err(_) => {
764                    stream.set_position(saved_pos);
765                    None
766                }
767            };
768            stream.expect_complete()?;
769            let saved_pos = stream.position();
770            let vec = match Vec::parse(stream) {
771                Ok(val) => Some(val),
772                Err(_) => {
773                    stream.set_position(saved_pos);
774                    None
775                }
776            };
777            stream.expect_complete()?;
778            let type_ = Type::parse(stream)?;
779            stream.expect_complete()?;
780            let a = AddressOperand::parse(stream)?;
781            stream.expect_complete()?;
782            stream.expect(&PtxToken::Comma)?;
783            let b = GeneralOperand::parse(stream)?;
784            stream.expect_complete()?;
785            stream.expect_complete()?;
786            stream.expect(&PtxToken::Semicolon)?;
787            Ok(StVolatileSsVecType {
788                volatile,
789                ss,
790                vec,
791                type_,
792                a,
793                b,
794            })
795        }
796    }
797
798    impl PtxParser
799        for StRelaxedScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType
800    {
801        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
802            stream.expect_string("st")?;
803            stream.expect_string(".relaxed")?;
804            let relaxed = ();
805            stream.expect_complete()?;
806            let scope = Scope::parse(stream)?;
807            stream.expect_complete()?;
808            let saved_pos = stream.position();
809            let ss = match Ss::parse(stream) {
810                Ok(val) => Some(val),
811                Err(_) => {
812                    stream.set_position(saved_pos);
813                    None
814                }
815            };
816            stream.expect_complete()?;
817            let saved_pos = stream.position();
818            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
819                Ok(val) => Some(val),
820                Err(_) => {
821                    stream.set_position(saved_pos);
822                    None
823                }
824            };
825            stream.expect_complete()?;
826            let saved_pos = stream.position();
827            let level2_eviction_priority = match Level2EvictionPriority::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 saved_pos = stream.position();
836            let level_cache_hint = match LevelCacheHint::parse(stream) {
837                Ok(val) => Some(val),
838                Err(_) => {
839                    stream.set_position(saved_pos);
840                    None
841                }
842            };
843            stream.expect_complete()?;
844            let saved_pos = stream.position();
845            let vec = match Vec::parse(stream) {
846                Ok(val) => Some(val),
847                Err(_) => {
848                    stream.set_position(saved_pos);
849                    None
850                }
851            };
852            stream.expect_complete()?;
853            let type_ = Type::parse(stream)?;
854            stream.expect_complete()?;
855            let a = AddressOperand::parse(stream)?;
856            stream.expect_complete()?;
857            stream.expect(&PtxToken::Comma)?;
858            let b = GeneralOperand::parse(stream)?;
859            stream.expect_complete()?;
860            let saved_pos = stream.position();
861            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
862            if !has_comma {
863                stream.set_position(saved_pos);
864            }
865            let saved_pos = stream.position();
866            let cache_policy = match GeneralOperand::parse(stream) {
867                Ok(val) => Some(val),
868                Err(_) => {
869                    stream.set_position(saved_pos);
870                    None
871                }
872            };
873            stream.expect_complete()?;
874            stream.expect_complete()?;
875            stream.expect(&PtxToken::Semicolon)?;
876            Ok(
877                StRelaxedScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType {
878                    relaxed,
879                    scope,
880                    ss,
881                    level1_eviction_priority,
882                    level2_eviction_priority,
883                    level_cache_hint,
884                    vec,
885                    type_,
886                    a,
887                    b,
888                    cache_policy,
889                },
890            )
891        }
892    }
893
894    impl PtxParser
895        for StReleaseScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType
896    {
897        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
898            stream.expect_string("st")?;
899            stream.expect_string(".release")?;
900            let release = ();
901            stream.expect_complete()?;
902            let scope = Scope::parse(stream)?;
903            stream.expect_complete()?;
904            let saved_pos = stream.position();
905            let ss = match Ss::parse(stream) {
906                Ok(val) => Some(val),
907                Err(_) => {
908                    stream.set_position(saved_pos);
909                    None
910                }
911            };
912            stream.expect_complete()?;
913            let saved_pos = stream.position();
914            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
915                Ok(val) => Some(val),
916                Err(_) => {
917                    stream.set_position(saved_pos);
918                    None
919                }
920            };
921            stream.expect_complete()?;
922            let saved_pos = stream.position();
923            let level2_eviction_priority = match Level2EvictionPriority::parse(stream) {
924                Ok(val) => Some(val),
925                Err(_) => {
926                    stream.set_position(saved_pos);
927                    None
928                }
929            };
930            stream.expect_complete()?;
931            let saved_pos = stream.position();
932            let level_cache_hint = match LevelCacheHint::parse(stream) {
933                Ok(val) => Some(val),
934                Err(_) => {
935                    stream.set_position(saved_pos);
936                    None
937                }
938            };
939            stream.expect_complete()?;
940            let saved_pos = stream.position();
941            let vec = match Vec::parse(stream) {
942                Ok(val) => Some(val),
943                Err(_) => {
944                    stream.set_position(saved_pos);
945                    None
946                }
947            };
948            stream.expect_complete()?;
949            let type_ = Type::parse(stream)?;
950            stream.expect_complete()?;
951            let a = AddressOperand::parse(stream)?;
952            stream.expect_complete()?;
953            stream.expect(&PtxToken::Comma)?;
954            let b = GeneralOperand::parse(stream)?;
955            stream.expect_complete()?;
956            let saved_pos = stream.position();
957            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
958            if !has_comma {
959                stream.set_position(saved_pos);
960            }
961            let saved_pos = stream.position();
962            let cache_policy = match GeneralOperand::parse(stream) {
963                Ok(val) => Some(val),
964                Err(_) => {
965                    stream.set_position(saved_pos);
966                    None
967                }
968            };
969            stream.expect_complete()?;
970            stream.expect_complete()?;
971            stream.expect(&PtxToken::Semicolon)?;
972            Ok(
973                StReleaseScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType {
974                    release,
975                    scope,
976                    ss,
977                    level1_eviction_priority,
978                    level2_eviction_priority,
979                    level_cache_hint,
980                    vec,
981                    type_,
982                    a,
983                    b,
984                    cache_policy,
985                },
986            )
987        }
988    }
989
990    impl PtxParser for StMmioRelaxedSysGlobalType {
991        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
992            stream.expect_string("st")?;
993            stream.expect_string(".mmio")?;
994            let mmio = ();
995            stream.expect_complete()?;
996            stream.expect_string(".relaxed")?;
997            let relaxed = ();
998            stream.expect_complete()?;
999            stream.expect_string(".sys")?;
1000            let sys = ();
1001            stream.expect_complete()?;
1002            let saved_pos = stream.position();
1003            let global = stream.expect_string(".global").is_ok();
1004            if !global {
1005                stream.set_position(saved_pos);
1006            }
1007            stream.expect_complete()?;
1008            let type_ = Type::parse(stream)?;
1009            stream.expect_complete()?;
1010            let a = AddressOperand::parse(stream)?;
1011            stream.expect_complete()?;
1012            stream.expect(&PtxToken::Comma)?;
1013            let b = GeneralOperand::parse(stream)?;
1014            stream.expect_complete()?;
1015            stream.expect_complete()?;
1016            stream.expect(&PtxToken::Semicolon)?;
1017            Ok(StMmioRelaxedSysGlobalType {
1018                mmio,
1019                relaxed,
1020                sys,
1021                global,
1022                type_,
1023                a,
1024                b,
1025            })
1026        }
1027    }
1028}
ptx_parser/parser/instruction/st.rs

ptx_parser/parser/instruction/
st.rs
