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

ptx_parser/parser/instruction/
atom.rs
