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

ptx_parser/parser/instruction/
st.rs
