ptx_parser/parser/instruction/
red.rs

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

ptx_parser/parser/instruction/
red.rs
