ptx_parser/parser/instruction/
atom.rs

1//! Original PTX specification:
2//!
3//! // Atomic operation with scalar type:
4//! atom{.sem}{.scope}{.space}.op{.level::cache_hint}.type d, [a], b{, cache-policy};
5//! atom{.sem}{.scope}{.space}.op.type d, [a], b, c;
6//! atom{.sem}{.scope}{.space}.cas.b16 d, [a], b, c;
7//! atom{.sem}{.scope}{.space}.cas.b128 d, [a], b, c;
8//! atom{.sem}{.scope}{.space}.exch{.level::cache_hint}.b128 d, [a], b {, cache-policy};
9//! atom{.sem}{.scope}{.space}.add.noftz{.level::cache_hint}.f16     d, [a], b{, cache-policy};
10//! atom{.sem}{.scope}{.space}.add.noftz{.level::cache_hint}.f16x2   d, [a], b{, cache-policy};
11//! atom{.sem}{.scope}{.space}.add.noftz{.level::cache_hint}.bf16    d, [a], b{, cache-policy};
12//! atom{.sem}{.scope}{.space}.add.noftz{.level::cache_hint}.bf16x2  d, [a], b{, cache-policy};
13//! .space =              { .global, .shared, .shared::cta, .shared::cluster};
14//! .sem =                { .relaxed, .acquire, .release, .acq_rel };
15//! .scope =              { .cta, .cluster, .gpu, .sys };
16//! .op =                 { .and, .or, .xor, .cas, .exch, .add, .inc, .dec, .min, .max };
17//! .level::cache_hint =  { .L2::cache_hint };
18//! .type =               { .b32, .b64, .u32, .u64, .s32, .s64, .f32, .f64 };
19//! -------------------------------------------------------------
20//! // Atomic operation with vector type:
21//! atom{.sem}{.scope}{.global}.add{.level::cache_hint}.vec_32_bit.f32                  d, [a], b{, cache-policy};
22//! atom{.sem}{.scope}{.global}.op.noftz{.level::cache_hint}.vec_16_bit.half_word_type  d, [a], b{, cache-policy};
23//! atom{.sem}{.scope}{.global}.op.noftz{.level::cache_hint}.vec_32_bit.packed_type     d, [a], b{, cache-policy};
24//! .sem =               { .relaxed, .acquire, .release, .acq_rel };
25//! .scope =             { .cta, .cluster, .gpu, .sys };
26//! .op =                { .add, .min, .max };
27//! .half_word_type =    { .f16, .bf16 };
28//! .packed_type =       { .f16x2, .bf16x2 };
29//! .vec_16_bit =        { .v2, .v4, .v8 };
30//! .vec_32_bit =        { .v2, .v4 };
31//! .level::cache_hint = { .L2::cache_hint };
32
33#![allow(unused)]
34
35use crate::lexer::PtxToken;
36use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
37use crate::r#type::common::*;
38
39pub mod section_0 {
40    use super::*;
41    use crate::r#type::instruction::atom::section_0::*;
42
43    // ============================================================================
44    // Generated enum parsers
45    // ============================================================================
46
47    impl PtxParser for LevelCacheHint {
48        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
49            // Try L2CacheHint
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".L2::cache_hint").is_ok() {
53                    return Ok(LevelCacheHint::L2CacheHint);
54                }
55                stream.set_position(saved_pos);
56            }
57            let span = stream
58                .peek()
59                .map(|(_, s)| s.clone())
60                .unwrap_or(Span { start: 0, end: 0 });
61            let expected = &[".L2::cache_hint"];
62            let found = stream
63                .peek()
64                .map(|(t, _)| format!("{:?}", t))
65                .unwrap_or_else(|_| "<end of input>".to_string());
66            Err(crate::parser::unexpected_value(span, expected, found))
67        }
68    }
69
70    impl PtxParser for Op {
71        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
72            // Try Exch
73            {
74                let saved_pos = stream.position();
75                if stream.expect_string(".exch").is_ok() {
76                    return Ok(Op::Exch);
77                }
78                stream.set_position(saved_pos);
79            }
80            let saved_pos = stream.position();
81            // Try And
82            {
83                let saved_pos = stream.position();
84                if stream.expect_string(".and").is_ok() {
85                    return Ok(Op::And);
86                }
87                stream.set_position(saved_pos);
88            }
89            stream.set_position(saved_pos);
90            let saved_pos = stream.position();
91            // Try Xor
92            {
93                let saved_pos = stream.position();
94                if stream.expect_string(".xor").is_ok() {
95                    return Ok(Op::Xor);
96                }
97                stream.set_position(saved_pos);
98            }
99            stream.set_position(saved_pos);
100            let saved_pos = stream.position();
101            // Try Cas
102            {
103                let saved_pos = stream.position();
104                if stream.expect_string(".cas").is_ok() {
105                    return Ok(Op::Cas);
106                }
107                stream.set_position(saved_pos);
108            }
109            stream.set_position(saved_pos);
110            let saved_pos = stream.position();
111            // Try Add
112            {
113                let saved_pos = stream.position();
114                if stream.expect_string(".add").is_ok() {
115                    return Ok(Op::Add);
116                }
117                stream.set_position(saved_pos);
118            }
119            stream.set_position(saved_pos);
120            let saved_pos = stream.position();
121            // Try Inc
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".inc").is_ok() {
125                    return Ok(Op::Inc);
126                }
127                stream.set_position(saved_pos);
128            }
129            stream.set_position(saved_pos);
130            let saved_pos = stream.position();
131            // Try Dec
132            {
133                let saved_pos = stream.position();
134                if stream.expect_string(".dec").is_ok() {
135                    return Ok(Op::Dec);
136                }
137                stream.set_position(saved_pos);
138            }
139            stream.set_position(saved_pos);
140            let saved_pos = stream.position();
141            // Try Min
142            {
143                let saved_pos = stream.position();
144                if stream.expect_string(".min").is_ok() {
145                    return Ok(Op::Min);
146                }
147                stream.set_position(saved_pos);
148            }
149            stream.set_position(saved_pos);
150            let saved_pos = stream.position();
151            // Try Max
152            {
153                let saved_pos = stream.position();
154                if stream.expect_string(".max").is_ok() {
155                    return Ok(Op::Max);
156                }
157                stream.set_position(saved_pos);
158            }
159            stream.set_position(saved_pos);
160            let saved_pos = stream.position();
161            // Try Or
162            {
163                let saved_pos = stream.position();
164                if stream.expect_string(".or").is_ok() {
165                    return Ok(Op::Or);
166                }
167                stream.set_position(saved_pos);
168            }
169            stream.set_position(saved_pos);
170            let span = stream
171                .peek()
172                .map(|(_, s)| s.clone())
173                .unwrap_or(Span { start: 0, end: 0 });
174            let expected = &[
175                ".exch", ".and", ".xor", ".cas", ".add", ".inc", ".dec", ".min", ".max", ".or",
176            ];
177            let found = stream
178                .peek()
179                .map(|(t, _)| format!("{:?}", t))
180                .unwrap_or_else(|_| "<end of input>".to_string());
181            Err(crate::parser::unexpected_value(span, expected, found))
182        }
183    }
184
185    impl PtxParser for Scope {
186        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
187            // Try Cluster
188            {
189                let saved_pos = stream.position();
190                if stream.expect_string(".cluster").is_ok() {
191                    return Ok(Scope::Cluster);
192                }
193                stream.set_position(saved_pos);
194            }
195            let saved_pos = stream.position();
196            // Try Cta
197            {
198                let saved_pos = stream.position();
199                if stream.expect_string(".cta").is_ok() {
200                    return Ok(Scope::Cta);
201                }
202                stream.set_position(saved_pos);
203            }
204            stream.set_position(saved_pos);
205            let saved_pos = stream.position();
206            // Try Gpu
207            {
208                let saved_pos = stream.position();
209                if stream.expect_string(".gpu").is_ok() {
210                    return Ok(Scope::Gpu);
211                }
212                stream.set_position(saved_pos);
213            }
214            stream.set_position(saved_pos);
215            let saved_pos = stream.position();
216            // Try Sys
217            {
218                let saved_pos = stream.position();
219                if stream.expect_string(".sys").is_ok() {
220                    return Ok(Scope::Sys);
221                }
222                stream.set_position(saved_pos);
223            }
224            stream.set_position(saved_pos);
225            let span = stream
226                .peek()
227                .map(|(_, s)| s.clone())
228                .unwrap_or(Span { start: 0, end: 0 });
229            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
230            let found = stream
231                .peek()
232                .map(|(t, _)| format!("{:?}", t))
233                .unwrap_or_else(|_| "<end of input>".to_string());
234            Err(crate::parser::unexpected_value(span, expected, found))
235        }
236    }
237
238    impl PtxParser for Sem {
239        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
240            // Try Relaxed
241            {
242                let saved_pos = stream.position();
243                if stream.expect_string(".relaxed").is_ok() {
244                    return Ok(Sem::Relaxed);
245                }
246                stream.set_position(saved_pos);
247            }
248            let saved_pos = stream.position();
249            // Try Acquire
250            {
251                let saved_pos = stream.position();
252                if stream.expect_string(".acquire").is_ok() {
253                    return Ok(Sem::Acquire);
254                }
255                stream.set_position(saved_pos);
256            }
257            stream.set_position(saved_pos);
258            let saved_pos = stream.position();
259            // Try Release
260            {
261                let saved_pos = stream.position();
262                if stream.expect_string(".release").is_ok() {
263                    return Ok(Sem::Release);
264                }
265                stream.set_position(saved_pos);
266            }
267            stream.set_position(saved_pos);
268            let saved_pos = stream.position();
269            // Try AcqRel
270            {
271                let saved_pos = stream.position();
272                if stream.expect_string(".acq_rel").is_ok() {
273                    return Ok(Sem::AcqRel);
274                }
275                stream.set_position(saved_pos);
276            }
277            stream.set_position(saved_pos);
278            let span = stream
279                .peek()
280                .map(|(_, s)| s.clone())
281                .unwrap_or(Span { start: 0, end: 0 });
282            let expected = &[".relaxed", ".acquire", ".release", ".acq_rel"];
283            let found = stream
284                .peek()
285                .map(|(t, _)| format!("{:?}", t))
286                .unwrap_or_else(|_| "<end of input>".to_string());
287            Err(crate::parser::unexpected_value(span, expected, found))
288        }
289    }
290
291    impl PtxParser for Space {
292        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
293            // Try SharedCluster
294            {
295                let saved_pos = stream.position();
296                if stream.expect_string(".shared::cluster").is_ok() {
297                    return Ok(Space::SharedCluster);
298                }
299                stream.set_position(saved_pos);
300            }
301            let saved_pos = stream.position();
302            // Try SharedCta
303            {
304                let saved_pos = stream.position();
305                if stream.expect_string(".shared::cta").is_ok() {
306                    return Ok(Space::SharedCta);
307                }
308                stream.set_position(saved_pos);
309            }
310            stream.set_position(saved_pos);
311            let saved_pos = stream.position();
312            // Try Global
313            {
314                let saved_pos = stream.position();
315                if stream.expect_string(".global").is_ok() {
316                    return Ok(Space::Global);
317                }
318                stream.set_position(saved_pos);
319            }
320            stream.set_position(saved_pos);
321            let saved_pos = stream.position();
322            // Try Shared
323            {
324                let saved_pos = stream.position();
325                if stream.expect_string(".shared").is_ok() {
326                    return Ok(Space::Shared);
327                }
328                stream.set_position(saved_pos);
329            }
330            stream.set_position(saved_pos);
331            let span = stream
332                .peek()
333                .map(|(_, s)| s.clone())
334                .unwrap_or(Span { start: 0, end: 0 });
335            let expected = &[".shared::cluster", ".shared::cta", ".global", ".shared"];
336            let found = stream
337                .peek()
338                .map(|(t, _)| format!("{:?}", t))
339                .unwrap_or_else(|_| "<end of input>".to_string());
340            Err(crate::parser::unexpected_value(span, expected, found))
341        }
342    }
343
344    impl PtxParser for Type {
345        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
346            // Try B32
347            {
348                let saved_pos = stream.position();
349                if stream.expect_string(".b32").is_ok() {
350                    return Ok(Type::B32);
351                }
352                stream.set_position(saved_pos);
353            }
354            let saved_pos = stream.position();
355            // Try B64
356            {
357                let saved_pos = stream.position();
358                if stream.expect_string(".b64").is_ok() {
359                    return Ok(Type::B64);
360                }
361                stream.set_position(saved_pos);
362            }
363            stream.set_position(saved_pos);
364            let saved_pos = stream.position();
365            // Try U32
366            {
367                let saved_pos = stream.position();
368                if stream.expect_string(".u32").is_ok() {
369                    return Ok(Type::U32);
370                }
371                stream.set_position(saved_pos);
372            }
373            stream.set_position(saved_pos);
374            let saved_pos = stream.position();
375            // Try U64
376            {
377                let saved_pos = stream.position();
378                if stream.expect_string(".u64").is_ok() {
379                    return Ok(Type::U64);
380                }
381                stream.set_position(saved_pos);
382            }
383            stream.set_position(saved_pos);
384            let saved_pos = stream.position();
385            // Try S32
386            {
387                let saved_pos = stream.position();
388                if stream.expect_string(".s32").is_ok() {
389                    return Ok(Type::S32);
390                }
391                stream.set_position(saved_pos);
392            }
393            stream.set_position(saved_pos);
394            let saved_pos = stream.position();
395            // Try S64
396            {
397                let saved_pos = stream.position();
398                if stream.expect_string(".s64").is_ok() {
399                    return Ok(Type::S64);
400                }
401                stream.set_position(saved_pos);
402            }
403            stream.set_position(saved_pos);
404            let saved_pos = stream.position();
405            // Try F32
406            {
407                let saved_pos = stream.position();
408                if stream.expect_string(".f32").is_ok() {
409                    return Ok(Type::F32);
410                }
411                stream.set_position(saved_pos);
412            }
413            stream.set_position(saved_pos);
414            let saved_pos = stream.position();
415            // Try F64
416            {
417                let saved_pos = stream.position();
418                if stream.expect_string(".f64").is_ok() {
419                    return Ok(Type::F64);
420                }
421                stream.set_position(saved_pos);
422            }
423            stream.set_position(saved_pos);
424            let span = stream
425                .peek()
426                .map(|(_, s)| s.clone())
427                .unwrap_or(Span { start: 0, end: 0 });
428            let expected = &[
429                ".b32", ".b64", ".u32", ".u64", ".s32", ".s64", ".f32", ".f64",
430            ];
431            let found = stream
432                .peek()
433                .map(|(t, _)| format!("{:?}", t))
434                .unwrap_or_else(|_| "<end of input>".to_string());
435            Err(crate::parser::unexpected_value(span, expected, found))
436        }
437    }
438
439    impl PtxParser for AtomSemScopeSpaceOpLevelCacheHintType {
440        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
441            stream.expect_string("atom")?;
442            let saved_pos = stream.position();
443            let sem = match Sem::parse(stream) {
444                Ok(val) => Some(val),
445                Err(_) => {
446                    stream.set_position(saved_pos);
447                    None
448                }
449            };
450            stream.expect_complete()?;
451            let saved_pos = stream.position();
452            let scope = match Scope::parse(stream) {
453                Ok(val) => Some(val),
454                Err(_) => {
455                    stream.set_position(saved_pos);
456                    None
457                }
458            };
459            stream.expect_complete()?;
460            let saved_pos = stream.position();
461            let space = match Space::parse(stream) {
462                Ok(val) => Some(val),
463                Err(_) => {
464                    stream.set_position(saved_pos);
465                    None
466                }
467            };
468            stream.expect_complete()?;
469            let op = Op::parse(stream)?;
470            stream.expect_complete()?;
471            let saved_pos = stream.position();
472            let level_cache_hint = match LevelCacheHint::parse(stream) {
473                Ok(val) => Some(val),
474                Err(_) => {
475                    stream.set_position(saved_pos);
476                    None
477                }
478            };
479            stream.expect_complete()?;
480            let type_ = Type::parse(stream)?;
481            stream.expect_complete()?;
482            let d = GeneralOperand::parse(stream)?;
483            stream.expect_complete()?;
484            stream.expect(&PtxToken::Comma)?;
485            let a = AddressOperand::parse(stream)?;
486            stream.expect_complete()?;
487            stream.expect(&PtxToken::Comma)?;
488            let b = GeneralOperand::parse(stream)?;
489            stream.expect_complete()?;
490            let saved_pos = stream.position();
491            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
492            if !has_comma {
493                stream.set_position(saved_pos);
494            }
495            let saved_pos = stream.position();
496            let cache_policy = match GeneralOperand::parse(stream) {
497                Ok(val) => Some(val),
498                Err(_) => {
499                    stream.set_position(saved_pos);
500                    None
501                }
502            };
503            stream.expect_complete()?;
504            stream.expect_complete()?;
505            stream.expect(&PtxToken::Semicolon)?;
506            Ok(AtomSemScopeSpaceOpLevelCacheHintType {
507                sem,
508                scope,
509                space,
510                op,
511                level_cache_hint,
512                type_,
513                d,
514                a,
515                b,
516                cache_policy,
517            })
518        }
519    }
520
521    impl PtxParser for AtomSemScopeSpaceOpType {
522        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
523            stream.expect_string("atom")?;
524            let saved_pos = stream.position();
525            let sem = match Sem::parse(stream) {
526                Ok(val) => Some(val),
527                Err(_) => {
528                    stream.set_position(saved_pos);
529                    None
530                }
531            };
532            stream.expect_complete()?;
533            let saved_pos = stream.position();
534            let scope = match Scope::parse(stream) {
535                Ok(val) => Some(val),
536                Err(_) => {
537                    stream.set_position(saved_pos);
538                    None
539                }
540            };
541            stream.expect_complete()?;
542            let saved_pos = stream.position();
543            let space = match Space::parse(stream) {
544                Ok(val) => Some(val),
545                Err(_) => {
546                    stream.set_position(saved_pos);
547                    None
548                }
549            };
550            stream.expect_complete()?;
551            let op = Op::parse(stream)?;
552            stream.expect_complete()?;
553            let type_ = Type::parse(stream)?;
554            stream.expect_complete()?;
555            let d = GeneralOperand::parse(stream)?;
556            stream.expect_complete()?;
557            stream.expect(&PtxToken::Comma)?;
558            let a = AddressOperand::parse(stream)?;
559            stream.expect_complete()?;
560            stream.expect(&PtxToken::Comma)?;
561            let b = GeneralOperand::parse(stream)?;
562            stream.expect_complete()?;
563            stream.expect(&PtxToken::Comma)?;
564            let c = GeneralOperand::parse(stream)?;
565            stream.expect_complete()?;
566            stream.expect_complete()?;
567            stream.expect(&PtxToken::Semicolon)?;
568            Ok(AtomSemScopeSpaceOpType {
569                sem,
570                scope,
571                space,
572                op,
573                type_,
574                d,
575                a,
576                b,
577                c,
578            })
579        }
580    }
581
582    impl PtxParser for AtomSemScopeSpaceCasB16 {
583        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
584            stream.expect_string("atom")?;
585            let saved_pos = stream.position();
586            let sem = match Sem::parse(stream) {
587                Ok(val) => Some(val),
588                Err(_) => {
589                    stream.set_position(saved_pos);
590                    None
591                }
592            };
593            stream.expect_complete()?;
594            let saved_pos = stream.position();
595            let scope = match Scope::parse(stream) {
596                Ok(val) => Some(val),
597                Err(_) => {
598                    stream.set_position(saved_pos);
599                    None
600                }
601            };
602            stream.expect_complete()?;
603            let saved_pos = stream.position();
604            let space = match Space::parse(stream) {
605                Ok(val) => Some(val),
606                Err(_) => {
607                    stream.set_position(saved_pos);
608                    None
609                }
610            };
611            stream.expect_complete()?;
612            stream.expect_string(".cas")?;
613            let cas = ();
614            stream.expect_complete()?;
615            stream.expect_string(".b16")?;
616            let b16 = ();
617            stream.expect_complete()?;
618            let d = GeneralOperand::parse(stream)?;
619            stream.expect_complete()?;
620            stream.expect(&PtxToken::Comma)?;
621            let a = AddressOperand::parse(stream)?;
622            stream.expect_complete()?;
623            stream.expect(&PtxToken::Comma)?;
624            let b = GeneralOperand::parse(stream)?;
625            stream.expect_complete()?;
626            stream.expect(&PtxToken::Comma)?;
627            let c = GeneralOperand::parse(stream)?;
628            stream.expect_complete()?;
629            stream.expect_complete()?;
630            stream.expect(&PtxToken::Semicolon)?;
631            Ok(AtomSemScopeSpaceCasB16 {
632                sem,
633                scope,
634                space,
635                cas,
636                b16,
637                d,
638                a,
639                b,
640                c,
641            })
642        }
643    }
644
645    impl PtxParser for AtomSemScopeSpaceCasB128 {
646        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
647            stream.expect_string("atom")?;
648            let saved_pos = stream.position();
649            let sem = match Sem::parse(stream) {
650                Ok(val) => Some(val),
651                Err(_) => {
652                    stream.set_position(saved_pos);
653                    None
654                }
655            };
656            stream.expect_complete()?;
657            let saved_pos = stream.position();
658            let scope = match Scope::parse(stream) {
659                Ok(val) => Some(val),
660                Err(_) => {
661                    stream.set_position(saved_pos);
662                    None
663                }
664            };
665            stream.expect_complete()?;
666            let saved_pos = stream.position();
667            let space = match Space::parse(stream) {
668                Ok(val) => Some(val),
669                Err(_) => {
670                    stream.set_position(saved_pos);
671                    None
672                }
673            };
674            stream.expect_complete()?;
675            stream.expect_string(".cas")?;
676            let cas = ();
677            stream.expect_complete()?;
678            stream.expect_string(".b128")?;
679            let b128 = ();
680            stream.expect_complete()?;
681            let d = GeneralOperand::parse(stream)?;
682            stream.expect_complete()?;
683            stream.expect(&PtxToken::Comma)?;
684            let a = AddressOperand::parse(stream)?;
685            stream.expect_complete()?;
686            stream.expect(&PtxToken::Comma)?;
687            let b = GeneralOperand::parse(stream)?;
688            stream.expect_complete()?;
689            stream.expect(&PtxToken::Comma)?;
690            let c = GeneralOperand::parse(stream)?;
691            stream.expect_complete()?;
692            stream.expect_complete()?;
693            stream.expect(&PtxToken::Semicolon)?;
694            Ok(AtomSemScopeSpaceCasB128 {
695                sem,
696                scope,
697                space,
698                cas,
699                b128,
700                d,
701                a,
702                b,
703                c,
704            })
705        }
706    }
707
708    impl PtxParser for AtomSemScopeSpaceExchLevelCacheHintB128 {
709        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
710            stream.expect_string("atom")?;
711            let saved_pos = stream.position();
712            let sem = match Sem::parse(stream) {
713                Ok(val) => Some(val),
714                Err(_) => {
715                    stream.set_position(saved_pos);
716                    None
717                }
718            };
719            stream.expect_complete()?;
720            let saved_pos = stream.position();
721            let scope = match Scope::parse(stream) {
722                Ok(val) => Some(val),
723                Err(_) => {
724                    stream.set_position(saved_pos);
725                    None
726                }
727            };
728            stream.expect_complete()?;
729            let saved_pos = stream.position();
730            let space = match Space::parse(stream) {
731                Ok(val) => Some(val),
732                Err(_) => {
733                    stream.set_position(saved_pos);
734                    None
735                }
736            };
737            stream.expect_complete()?;
738            stream.expect_string(".exch")?;
739            let exch = ();
740            stream.expect_complete()?;
741            let saved_pos = stream.position();
742            let level_cache_hint = match LevelCacheHint::parse(stream) {
743                Ok(val) => Some(val),
744                Err(_) => {
745                    stream.set_position(saved_pos);
746                    None
747                }
748            };
749            stream.expect_complete()?;
750            stream.expect_string(".b128")?;
751            let b128 = ();
752            stream.expect_complete()?;
753            let d = GeneralOperand::parse(stream)?;
754            stream.expect_complete()?;
755            stream.expect(&PtxToken::Comma)?;
756            let a = AddressOperand::parse(stream)?;
757            stream.expect_complete()?;
758            stream.expect(&PtxToken::Comma)?;
759            let b = GeneralOperand::parse(stream)?;
760            stream.expect_complete()?;
761            let saved_pos = stream.position();
762            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
763            if !has_comma {
764                stream.set_position(saved_pos);
765            }
766            let saved_pos = stream.position();
767            let cache_policy = match GeneralOperand::parse(stream) {
768                Ok(val) => Some(val),
769                Err(_) => {
770                    stream.set_position(saved_pos);
771                    None
772                }
773            };
774            stream.expect_complete()?;
775            stream.expect_complete()?;
776            stream.expect(&PtxToken::Semicolon)?;
777            Ok(AtomSemScopeSpaceExchLevelCacheHintB128 {
778                sem,
779                scope,
780                space,
781                exch,
782                level_cache_hint,
783                b128,
784                d,
785                a,
786                b,
787                cache_policy,
788            })
789        }
790    }
791
792    impl PtxParser for AtomSemScopeSpaceAddNoftzLevelCacheHintF16 {
793        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
794            stream.expect_string("atom")?;
795            let saved_pos = stream.position();
796            let sem = match Sem::parse(stream) {
797                Ok(val) => Some(val),
798                Err(_) => {
799                    stream.set_position(saved_pos);
800                    None
801                }
802            };
803            stream.expect_complete()?;
804            let saved_pos = stream.position();
805            let scope = match Scope::parse(stream) {
806                Ok(val) => Some(val),
807                Err(_) => {
808                    stream.set_position(saved_pos);
809                    None
810                }
811            };
812            stream.expect_complete()?;
813            let saved_pos = stream.position();
814            let space = match Space::parse(stream) {
815                Ok(val) => Some(val),
816                Err(_) => {
817                    stream.set_position(saved_pos);
818                    None
819                }
820            };
821            stream.expect_complete()?;
822            stream.expect_string(".add")?;
823            let add = ();
824            stream.expect_complete()?;
825            stream.expect_string(".noftz")?;
826            let noftz = ();
827            stream.expect_complete()?;
828            let saved_pos = stream.position();
829            let level_cache_hint = match LevelCacheHint::parse(stream) {
830                Ok(val) => Some(val),
831                Err(_) => {
832                    stream.set_position(saved_pos);
833                    None
834                }
835            };
836            stream.expect_complete()?;
837            stream.expect_string(".f16")?;
838            let f16 = ();
839            stream.expect_complete()?;
840            let d = GeneralOperand::parse(stream)?;
841            stream.expect_complete()?;
842            stream.expect(&PtxToken::Comma)?;
843            let a = AddressOperand::parse(stream)?;
844            stream.expect_complete()?;
845            stream.expect(&PtxToken::Comma)?;
846            let b = GeneralOperand::parse(stream)?;
847            stream.expect_complete()?;
848            let saved_pos = stream.position();
849            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
850            if !has_comma {
851                stream.set_position(saved_pos);
852            }
853            let saved_pos = stream.position();
854            let cache_policy = match GeneralOperand::parse(stream) {
855                Ok(val) => Some(val),
856                Err(_) => {
857                    stream.set_position(saved_pos);
858                    None
859                }
860            };
861            stream.expect_complete()?;
862            stream.expect_complete()?;
863            stream.expect(&PtxToken::Semicolon)?;
864            Ok(AtomSemScopeSpaceAddNoftzLevelCacheHintF16 {
865                sem,
866                scope,
867                space,
868                add,
869                noftz,
870                level_cache_hint,
871                f16,
872                d,
873                a,
874                b,
875                cache_policy,
876            })
877        }
878    }
879
880    impl PtxParser for AtomSemScopeSpaceAddNoftzLevelCacheHintF16x2 {
881        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
882            stream.expect_string("atom")?;
883            let saved_pos = stream.position();
884            let sem = match Sem::parse(stream) {
885                Ok(val) => Some(val),
886                Err(_) => {
887                    stream.set_position(saved_pos);
888                    None
889                }
890            };
891            stream.expect_complete()?;
892            let saved_pos = stream.position();
893            let scope = match Scope::parse(stream) {
894                Ok(val) => Some(val),
895                Err(_) => {
896                    stream.set_position(saved_pos);
897                    None
898                }
899            };
900            stream.expect_complete()?;
901            let saved_pos = stream.position();
902            let space = match Space::parse(stream) {
903                Ok(val) => Some(val),
904                Err(_) => {
905                    stream.set_position(saved_pos);
906                    None
907                }
908            };
909            stream.expect_complete()?;
910            stream.expect_string(".add")?;
911            let add = ();
912            stream.expect_complete()?;
913            stream.expect_string(".noftz")?;
914            let noftz = ();
915            stream.expect_complete()?;
916            let saved_pos = stream.position();
917            let level_cache_hint = match LevelCacheHint::parse(stream) {
918                Ok(val) => Some(val),
919                Err(_) => {
920                    stream.set_position(saved_pos);
921                    None
922                }
923            };
924            stream.expect_complete()?;
925            stream.expect_string(".f16x2")?;
926            let f16x2 = ();
927            stream.expect_complete()?;
928            let d = GeneralOperand::parse(stream)?;
929            stream.expect_complete()?;
930            stream.expect(&PtxToken::Comma)?;
931            let a = AddressOperand::parse(stream)?;
932            stream.expect_complete()?;
933            stream.expect(&PtxToken::Comma)?;
934            let b = GeneralOperand::parse(stream)?;
935            stream.expect_complete()?;
936            let saved_pos = stream.position();
937            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
938            if !has_comma {
939                stream.set_position(saved_pos);
940            }
941            let saved_pos = stream.position();
942            let cache_policy = match GeneralOperand::parse(stream) {
943                Ok(val) => Some(val),
944                Err(_) => {
945                    stream.set_position(saved_pos);
946                    None
947                }
948            };
949            stream.expect_complete()?;
950            stream.expect_complete()?;
951            stream.expect(&PtxToken::Semicolon)?;
952            Ok(AtomSemScopeSpaceAddNoftzLevelCacheHintF16x2 {
953                sem,
954                scope,
955                space,
956                add,
957                noftz,
958                level_cache_hint,
959                f16x2,
960                d,
961                a,
962                b,
963                cache_policy,
964            })
965        }
966    }
967
968    impl PtxParser for AtomSemScopeSpaceAddNoftzLevelCacheHintBf16 {
969        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
970            stream.expect_string("atom")?;
971            let saved_pos = stream.position();
972            let sem = match Sem::parse(stream) {
973                Ok(val) => Some(val),
974                Err(_) => {
975                    stream.set_position(saved_pos);
976                    None
977                }
978            };
979            stream.expect_complete()?;
980            let saved_pos = stream.position();
981            let scope = match Scope::parse(stream) {
982                Ok(val) => Some(val),
983                Err(_) => {
984                    stream.set_position(saved_pos);
985                    None
986                }
987            };
988            stream.expect_complete()?;
989            let saved_pos = stream.position();
990            let space = match Space::parse(stream) {
991                Ok(val) => Some(val),
992                Err(_) => {
993                    stream.set_position(saved_pos);
994                    None
995                }
996            };
997            stream.expect_complete()?;
998            stream.expect_string(".add")?;
999            let add = ();
1000            stream.expect_complete()?;
1001            stream.expect_string(".noftz")?;
1002            let noftz = ();
1003            stream.expect_complete()?;
1004            let saved_pos = stream.position();
1005            let level_cache_hint = match LevelCacheHint::parse(stream) {
1006                Ok(val) => Some(val),
1007                Err(_) => {
1008                    stream.set_position(saved_pos);
1009                    None
1010                }
1011            };
1012            stream.expect_complete()?;
1013            stream.expect_string(".bf16")?;
1014            let bf16 = ();
1015            stream.expect_complete()?;
1016            let d = GeneralOperand::parse(stream)?;
1017            stream.expect_complete()?;
1018            stream.expect(&PtxToken::Comma)?;
1019            let a = AddressOperand::parse(stream)?;
1020            stream.expect_complete()?;
1021            stream.expect(&PtxToken::Comma)?;
1022            let b = GeneralOperand::parse(stream)?;
1023            stream.expect_complete()?;
1024            let saved_pos = stream.position();
1025            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1026            if !has_comma {
1027                stream.set_position(saved_pos);
1028            }
1029            let saved_pos = stream.position();
1030            let cache_policy = match GeneralOperand::parse(stream) {
1031                Ok(val) => Some(val),
1032                Err(_) => {
1033                    stream.set_position(saved_pos);
1034                    None
1035                }
1036            };
1037            stream.expect_complete()?;
1038            stream.expect_complete()?;
1039            stream.expect(&PtxToken::Semicolon)?;
1040            Ok(AtomSemScopeSpaceAddNoftzLevelCacheHintBf16 {
1041                sem,
1042                scope,
1043                space,
1044                add,
1045                noftz,
1046                level_cache_hint,
1047                bf16,
1048                d,
1049                a,
1050                b,
1051                cache_policy,
1052            })
1053        }
1054    }
1055
1056    impl PtxParser for AtomSemScopeSpaceAddNoftzLevelCacheHintBf16x2 {
1057        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1058            stream.expect_string("atom")?;
1059            let saved_pos = stream.position();
1060            let sem = match Sem::parse(stream) {
1061                Ok(val) => Some(val),
1062                Err(_) => {
1063                    stream.set_position(saved_pos);
1064                    None
1065                }
1066            };
1067            stream.expect_complete()?;
1068            let saved_pos = stream.position();
1069            let scope = match Scope::parse(stream) {
1070                Ok(val) => Some(val),
1071                Err(_) => {
1072                    stream.set_position(saved_pos);
1073                    None
1074                }
1075            };
1076            stream.expect_complete()?;
1077            let saved_pos = stream.position();
1078            let space = match Space::parse(stream) {
1079                Ok(val) => Some(val),
1080                Err(_) => {
1081                    stream.set_position(saved_pos);
1082                    None
1083                }
1084            };
1085            stream.expect_complete()?;
1086            stream.expect_string(".add")?;
1087            let add = ();
1088            stream.expect_complete()?;
1089            stream.expect_string(".noftz")?;
1090            let noftz = ();
1091            stream.expect_complete()?;
1092            let saved_pos = stream.position();
1093            let level_cache_hint = match LevelCacheHint::parse(stream) {
1094                Ok(val) => Some(val),
1095                Err(_) => {
1096                    stream.set_position(saved_pos);
1097                    None
1098                }
1099            };
1100            stream.expect_complete()?;
1101            stream.expect_string(".bf16x2")?;
1102            let bf16x2 = ();
1103            stream.expect_complete()?;
1104            let d = GeneralOperand::parse(stream)?;
1105            stream.expect_complete()?;
1106            stream.expect(&PtxToken::Comma)?;
1107            let a = AddressOperand::parse(stream)?;
1108            stream.expect_complete()?;
1109            stream.expect(&PtxToken::Comma)?;
1110            let b = GeneralOperand::parse(stream)?;
1111            stream.expect_complete()?;
1112            let saved_pos = stream.position();
1113            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1114            if !has_comma {
1115                stream.set_position(saved_pos);
1116            }
1117            let saved_pos = stream.position();
1118            let cache_policy = match GeneralOperand::parse(stream) {
1119                Ok(val) => Some(val),
1120                Err(_) => {
1121                    stream.set_position(saved_pos);
1122                    None
1123                }
1124            };
1125            stream.expect_complete()?;
1126            stream.expect_complete()?;
1127            stream.expect(&PtxToken::Semicolon)?;
1128            Ok(AtomSemScopeSpaceAddNoftzLevelCacheHintBf16x2 {
1129                sem,
1130                scope,
1131                space,
1132                add,
1133                noftz,
1134                level_cache_hint,
1135                bf16x2,
1136                d,
1137                a,
1138                b,
1139                cache_policy,
1140            })
1141        }
1142    }
1143}
1144
1145pub mod section_1 {
1146    use super::*;
1147    use crate::r#type::instruction::atom::section_1::*;
1148
1149    // ============================================================================
1150    // Generated enum parsers
1151    // ============================================================================
1152
1153    impl PtxParser for HalfWordType {
1154        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1155            // Try Bf16
1156            {
1157                let saved_pos = stream.position();
1158                if stream.expect_string(".bf16").is_ok() {
1159                    return Ok(HalfWordType::Bf16);
1160                }
1161                stream.set_position(saved_pos);
1162            }
1163            let saved_pos = stream.position();
1164            // Try F16
1165            {
1166                let saved_pos = stream.position();
1167                if stream.expect_string(".f16").is_ok() {
1168                    return Ok(HalfWordType::F16);
1169                }
1170                stream.set_position(saved_pos);
1171            }
1172            stream.set_position(saved_pos);
1173            let span = stream
1174                .peek()
1175                .map(|(_, s)| s.clone())
1176                .unwrap_or(Span { start: 0, end: 0 });
1177            let expected = &[".bf16", ".f16"];
1178            let found = stream
1179                .peek()
1180                .map(|(t, _)| format!("{:?}", t))
1181                .unwrap_or_else(|_| "<end of input>".to_string());
1182            Err(crate::parser::unexpected_value(span, expected, found))
1183        }
1184    }
1185
1186    impl PtxParser for LevelCacheHint {
1187        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1188            // Try L2CacheHint
1189            {
1190                let saved_pos = stream.position();
1191                if stream.expect_string(".L2::cache_hint").is_ok() {
1192                    return Ok(LevelCacheHint::L2CacheHint);
1193                }
1194                stream.set_position(saved_pos);
1195            }
1196            let span = stream
1197                .peek()
1198                .map(|(_, s)| s.clone())
1199                .unwrap_or(Span { start: 0, end: 0 });
1200            let expected = &[".L2::cache_hint"];
1201            let found = stream
1202                .peek()
1203                .map(|(t, _)| format!("{:?}", t))
1204                .unwrap_or_else(|_| "<end of input>".to_string());
1205            Err(crate::parser::unexpected_value(span, expected, found))
1206        }
1207    }
1208
1209    impl PtxParser for Op {
1210        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1211            // Try Add
1212            {
1213                let saved_pos = stream.position();
1214                if stream.expect_string(".add").is_ok() {
1215                    return Ok(Op::Add);
1216                }
1217                stream.set_position(saved_pos);
1218            }
1219            let saved_pos = stream.position();
1220            // Try Min
1221            {
1222                let saved_pos = stream.position();
1223                if stream.expect_string(".min").is_ok() {
1224                    return Ok(Op::Min);
1225                }
1226                stream.set_position(saved_pos);
1227            }
1228            stream.set_position(saved_pos);
1229            let saved_pos = stream.position();
1230            // Try Max
1231            {
1232                let saved_pos = stream.position();
1233                if stream.expect_string(".max").is_ok() {
1234                    return Ok(Op::Max);
1235                }
1236                stream.set_position(saved_pos);
1237            }
1238            stream.set_position(saved_pos);
1239            let span = stream
1240                .peek()
1241                .map(|(_, s)| s.clone())
1242                .unwrap_or(Span { start: 0, end: 0 });
1243            let expected = &[".add", ".min", ".max"];
1244            let found = stream
1245                .peek()
1246                .map(|(t, _)| format!("{:?}", t))
1247                .unwrap_or_else(|_| "<end of input>".to_string());
1248            Err(crate::parser::unexpected_value(span, expected, found))
1249        }
1250    }
1251
1252    impl PtxParser for PackedType {
1253        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1254            // Try Bf16x2
1255            {
1256                let saved_pos = stream.position();
1257                if stream.expect_string(".bf16x2").is_ok() {
1258                    return Ok(PackedType::Bf16x2);
1259                }
1260                stream.set_position(saved_pos);
1261            }
1262            let saved_pos = stream.position();
1263            // Try F16x2
1264            {
1265                let saved_pos = stream.position();
1266                if stream.expect_string(".f16x2").is_ok() {
1267                    return Ok(PackedType::F16x2);
1268                }
1269                stream.set_position(saved_pos);
1270            }
1271            stream.set_position(saved_pos);
1272            let span = stream
1273                .peek()
1274                .map(|(_, s)| s.clone())
1275                .unwrap_or(Span { start: 0, end: 0 });
1276            let expected = &[".bf16x2", ".f16x2"];
1277            let found = stream
1278                .peek()
1279                .map(|(t, _)| format!("{:?}", t))
1280                .unwrap_or_else(|_| "<end of input>".to_string());
1281            Err(crate::parser::unexpected_value(span, expected, found))
1282        }
1283    }
1284
1285    impl PtxParser for Scope {
1286        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1287            // Try Cluster
1288            {
1289                let saved_pos = stream.position();
1290                if stream.expect_string(".cluster").is_ok() {
1291                    return Ok(Scope::Cluster);
1292                }
1293                stream.set_position(saved_pos);
1294            }
1295            let saved_pos = stream.position();
1296            // Try Cta
1297            {
1298                let saved_pos = stream.position();
1299                if stream.expect_string(".cta").is_ok() {
1300                    return Ok(Scope::Cta);
1301                }
1302                stream.set_position(saved_pos);
1303            }
1304            stream.set_position(saved_pos);
1305            let saved_pos = stream.position();
1306            // Try Gpu
1307            {
1308                let saved_pos = stream.position();
1309                if stream.expect_string(".gpu").is_ok() {
1310                    return Ok(Scope::Gpu);
1311                }
1312                stream.set_position(saved_pos);
1313            }
1314            stream.set_position(saved_pos);
1315            let saved_pos = stream.position();
1316            // Try Sys
1317            {
1318                let saved_pos = stream.position();
1319                if stream.expect_string(".sys").is_ok() {
1320                    return Ok(Scope::Sys);
1321                }
1322                stream.set_position(saved_pos);
1323            }
1324            stream.set_position(saved_pos);
1325            let span = stream
1326                .peek()
1327                .map(|(_, s)| s.clone())
1328                .unwrap_or(Span { start: 0, end: 0 });
1329            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
1330            let found = stream
1331                .peek()
1332                .map(|(t, _)| format!("{:?}", t))
1333                .unwrap_or_else(|_| "<end of input>".to_string());
1334            Err(crate::parser::unexpected_value(span, expected, found))
1335        }
1336    }
1337
1338    impl PtxParser for Sem {
1339        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1340            // Try Relaxed
1341            {
1342                let saved_pos = stream.position();
1343                if stream.expect_string(".relaxed").is_ok() {
1344                    return Ok(Sem::Relaxed);
1345                }
1346                stream.set_position(saved_pos);
1347            }
1348            let saved_pos = stream.position();
1349            // Try Acquire
1350            {
1351                let saved_pos = stream.position();
1352                if stream.expect_string(".acquire").is_ok() {
1353                    return Ok(Sem::Acquire);
1354                }
1355                stream.set_position(saved_pos);
1356            }
1357            stream.set_position(saved_pos);
1358            let saved_pos = stream.position();
1359            // Try Release
1360            {
1361                let saved_pos = stream.position();
1362                if stream.expect_string(".release").is_ok() {
1363                    return Ok(Sem::Release);
1364                }
1365                stream.set_position(saved_pos);
1366            }
1367            stream.set_position(saved_pos);
1368            let saved_pos = stream.position();
1369            // Try AcqRel
1370            {
1371                let saved_pos = stream.position();
1372                if stream.expect_string(".acq_rel").is_ok() {
1373                    return Ok(Sem::AcqRel);
1374                }
1375                stream.set_position(saved_pos);
1376            }
1377            stream.set_position(saved_pos);
1378            let span = stream
1379                .peek()
1380                .map(|(_, s)| s.clone())
1381                .unwrap_or(Span { start: 0, end: 0 });
1382            let expected = &[".relaxed", ".acquire", ".release", ".acq_rel"];
1383            let found = stream
1384                .peek()
1385                .map(|(t, _)| format!("{:?}", t))
1386                .unwrap_or_else(|_| "<end of input>".to_string());
1387            Err(crate::parser::unexpected_value(span, expected, found))
1388        }
1389    }
1390
1391    impl PtxParser for Vec16Bit {
1392        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1393            // Try V2
1394            {
1395                let saved_pos = stream.position();
1396                if stream.expect_string(".v2").is_ok() {
1397                    return Ok(Vec16Bit::V2);
1398                }
1399                stream.set_position(saved_pos);
1400            }
1401            let saved_pos = stream.position();
1402            // Try V4
1403            {
1404                let saved_pos = stream.position();
1405                if stream.expect_string(".v4").is_ok() {
1406                    return Ok(Vec16Bit::V4);
1407                }
1408                stream.set_position(saved_pos);
1409            }
1410            stream.set_position(saved_pos);
1411            let saved_pos = stream.position();
1412            // Try V8
1413            {
1414                let saved_pos = stream.position();
1415                if stream.expect_string(".v8").is_ok() {
1416                    return Ok(Vec16Bit::V8);
1417                }
1418                stream.set_position(saved_pos);
1419            }
1420            stream.set_position(saved_pos);
1421            let span = stream
1422                .peek()
1423                .map(|(_, s)| s.clone())
1424                .unwrap_or(Span { start: 0, end: 0 });
1425            let expected = &[".v2", ".v4", ".v8"];
1426            let found = stream
1427                .peek()
1428                .map(|(t, _)| format!("{:?}", t))
1429                .unwrap_or_else(|_| "<end of input>".to_string());
1430            Err(crate::parser::unexpected_value(span, expected, found))
1431        }
1432    }
1433
1434    impl PtxParser for Vec32Bit {
1435        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1436            // Try V2
1437            {
1438                let saved_pos = stream.position();
1439                if stream.expect_string(".v2").is_ok() {
1440                    return Ok(Vec32Bit::V2);
1441                }
1442                stream.set_position(saved_pos);
1443            }
1444            let saved_pos = stream.position();
1445            // Try V4
1446            {
1447                let saved_pos = stream.position();
1448                if stream.expect_string(".v4").is_ok() {
1449                    return Ok(Vec32Bit::V4);
1450                }
1451                stream.set_position(saved_pos);
1452            }
1453            stream.set_position(saved_pos);
1454            let span = stream
1455                .peek()
1456                .map(|(_, s)| s.clone())
1457                .unwrap_or(Span { start: 0, end: 0 });
1458            let expected = &[".v2", ".v4"];
1459            let found = stream
1460                .peek()
1461                .map(|(t, _)| format!("{:?}", t))
1462                .unwrap_or_else(|_| "<end of input>".to_string());
1463            Err(crate::parser::unexpected_value(span, expected, found))
1464        }
1465    }
1466
1467    impl PtxParser for AtomSemScopeGlobalAddLevelCacheHintVec32BitF32 {
1468        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1469            stream.expect_string("atom")?;
1470            let saved_pos = stream.position();
1471            let sem = match Sem::parse(stream) {
1472                Ok(val) => Some(val),
1473                Err(_) => {
1474                    stream.set_position(saved_pos);
1475                    None
1476                }
1477            };
1478            stream.expect_complete()?;
1479            let saved_pos = stream.position();
1480            let scope = match Scope::parse(stream) {
1481                Ok(val) => Some(val),
1482                Err(_) => {
1483                    stream.set_position(saved_pos);
1484                    None
1485                }
1486            };
1487            stream.expect_complete()?;
1488            let saved_pos = stream.position();
1489            let global = stream.expect_string(".global").is_ok();
1490            if !global {
1491                stream.set_position(saved_pos);
1492            }
1493            stream.expect_complete()?;
1494            stream.expect_string(".add")?;
1495            let add = ();
1496            stream.expect_complete()?;
1497            let saved_pos = stream.position();
1498            let level_cache_hint = match LevelCacheHint::parse(stream) {
1499                Ok(val) => Some(val),
1500                Err(_) => {
1501                    stream.set_position(saved_pos);
1502                    None
1503                }
1504            };
1505            stream.expect_complete()?;
1506            let vec_32_bit = Vec32Bit::parse(stream)?;
1507            stream.expect_complete()?;
1508            stream.expect_string(".f32")?;
1509            let f32 = ();
1510            stream.expect_complete()?;
1511            let d = GeneralOperand::parse(stream)?;
1512            stream.expect_complete()?;
1513            stream.expect(&PtxToken::Comma)?;
1514            let a = AddressOperand::parse(stream)?;
1515            stream.expect_complete()?;
1516            stream.expect(&PtxToken::Comma)?;
1517            let b = GeneralOperand::parse(stream)?;
1518            stream.expect_complete()?;
1519            let saved_pos = stream.position();
1520            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1521            if !has_comma {
1522                stream.set_position(saved_pos);
1523            }
1524            let saved_pos = stream.position();
1525            let cache_policy = match GeneralOperand::parse(stream) {
1526                Ok(val) => Some(val),
1527                Err(_) => {
1528                    stream.set_position(saved_pos);
1529                    None
1530                }
1531            };
1532            stream.expect_complete()?;
1533            stream.expect_complete()?;
1534            stream.expect(&PtxToken::Semicolon)?;
1535            Ok(AtomSemScopeGlobalAddLevelCacheHintVec32BitF32 {
1536                sem,
1537                scope,
1538                global,
1539                add,
1540                level_cache_hint,
1541                vec_32_bit,
1542                f32,
1543                d,
1544                a,
1545                b,
1546                cache_policy,
1547            })
1548        }
1549    }
1550
1551    impl PtxParser for AtomSemScopeGlobalOpNoftzLevelCacheHintVec16BitHalfWordType {
1552        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1553            stream.expect_string("atom")?;
1554            let saved_pos = stream.position();
1555            let sem = match Sem::parse(stream) {
1556                Ok(val) => Some(val),
1557                Err(_) => {
1558                    stream.set_position(saved_pos);
1559                    None
1560                }
1561            };
1562            stream.expect_complete()?;
1563            let saved_pos = stream.position();
1564            let scope = match Scope::parse(stream) {
1565                Ok(val) => Some(val),
1566                Err(_) => {
1567                    stream.set_position(saved_pos);
1568                    None
1569                }
1570            };
1571            stream.expect_complete()?;
1572            let saved_pos = stream.position();
1573            let global = stream.expect_string(".global").is_ok();
1574            if !global {
1575                stream.set_position(saved_pos);
1576            }
1577            stream.expect_complete()?;
1578            let op = Op::parse(stream)?;
1579            stream.expect_complete()?;
1580            stream.expect_string(".noftz")?;
1581            let noftz = ();
1582            stream.expect_complete()?;
1583            let saved_pos = stream.position();
1584            let level_cache_hint = match LevelCacheHint::parse(stream) {
1585                Ok(val) => Some(val),
1586                Err(_) => {
1587                    stream.set_position(saved_pos);
1588                    None
1589                }
1590            };
1591            stream.expect_complete()?;
1592            let vec_16_bit = Vec16Bit::parse(stream)?;
1593            stream.expect_complete()?;
1594            let half_word_type = HalfWordType::parse(stream)?;
1595            stream.expect_complete()?;
1596            let d = GeneralOperand::parse(stream)?;
1597            stream.expect_complete()?;
1598            stream.expect(&PtxToken::Comma)?;
1599            let a = AddressOperand::parse(stream)?;
1600            stream.expect_complete()?;
1601            stream.expect(&PtxToken::Comma)?;
1602            let b = GeneralOperand::parse(stream)?;
1603            stream.expect_complete()?;
1604            let saved_pos = stream.position();
1605            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1606            if !has_comma {
1607                stream.set_position(saved_pos);
1608            }
1609            let saved_pos = stream.position();
1610            let cache_policy = match GeneralOperand::parse(stream) {
1611                Ok(val) => Some(val),
1612                Err(_) => {
1613                    stream.set_position(saved_pos);
1614                    None
1615                }
1616            };
1617            stream.expect_complete()?;
1618            stream.expect_complete()?;
1619            stream.expect(&PtxToken::Semicolon)?;
1620            Ok(
1621                AtomSemScopeGlobalOpNoftzLevelCacheHintVec16BitHalfWordType {
1622                    sem,
1623                    scope,
1624                    global,
1625                    op,
1626                    noftz,
1627                    level_cache_hint,
1628                    vec_16_bit,
1629                    half_word_type,
1630                    d,
1631                    a,
1632                    b,
1633                    cache_policy,
1634                },
1635            )
1636        }
1637    }
1638
1639    impl PtxParser for AtomSemScopeGlobalOpNoftzLevelCacheHintVec32BitPackedType {
1640        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1641            stream.expect_string("atom")?;
1642            let saved_pos = stream.position();
1643            let sem = match Sem::parse(stream) {
1644                Ok(val) => Some(val),
1645                Err(_) => {
1646                    stream.set_position(saved_pos);
1647                    None
1648                }
1649            };
1650            stream.expect_complete()?;
1651            let saved_pos = stream.position();
1652            let scope = match Scope::parse(stream) {
1653                Ok(val) => Some(val),
1654                Err(_) => {
1655                    stream.set_position(saved_pos);
1656                    None
1657                }
1658            };
1659            stream.expect_complete()?;
1660            let saved_pos = stream.position();
1661            let global = stream.expect_string(".global").is_ok();
1662            if !global {
1663                stream.set_position(saved_pos);
1664            }
1665            stream.expect_complete()?;
1666            let op = Op::parse(stream)?;
1667            stream.expect_complete()?;
1668            stream.expect_string(".noftz")?;
1669            let noftz = ();
1670            stream.expect_complete()?;
1671            let saved_pos = stream.position();
1672            let level_cache_hint = match LevelCacheHint::parse(stream) {
1673                Ok(val) => Some(val),
1674                Err(_) => {
1675                    stream.set_position(saved_pos);
1676                    None
1677                }
1678            };
1679            stream.expect_complete()?;
1680            let vec_32_bit = Vec32Bit::parse(stream)?;
1681            stream.expect_complete()?;
1682            let packed_type = PackedType::parse(stream)?;
1683            stream.expect_complete()?;
1684            let d = GeneralOperand::parse(stream)?;
1685            stream.expect_complete()?;
1686            stream.expect(&PtxToken::Comma)?;
1687            let a = AddressOperand::parse(stream)?;
1688            stream.expect_complete()?;
1689            stream.expect(&PtxToken::Comma)?;
1690            let b = GeneralOperand::parse(stream)?;
1691            stream.expect_complete()?;
1692            let saved_pos = stream.position();
1693            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1694            if !has_comma {
1695                stream.set_position(saved_pos);
1696            }
1697            let saved_pos = stream.position();
1698            let cache_policy = match GeneralOperand::parse(stream) {
1699                Ok(val) => Some(val),
1700                Err(_) => {
1701                    stream.set_position(saved_pos);
1702                    None
1703                }
1704            };
1705            stream.expect_complete()?;
1706            stream.expect_complete()?;
1707            stream.expect(&PtxToken::Semicolon)?;
1708            Ok(AtomSemScopeGlobalOpNoftzLevelCacheHintVec32BitPackedType {
1709                sem,
1710                scope,
1711                global,
1712                op,
1713                noftz,
1714                level_cache_hint,
1715                vec_32_bit,
1716                packed_type,
1717                d,
1718                a,
1719                b,
1720                cache_policy,
1721            })
1722        }
1723    }
1724}
ptx_parser/parser/instruction/atom.rs

ptx_parser/parser/instruction/
atom.rs
