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

ptx_parser/parser/instruction/
red.rs
