ptx_parser/parser/instruction/
multimem_ld_reduce.rs

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

ptx_parser/parser/instruction/
multimem_ld_reduce.rs
