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

ptx_parser/parser/instruction/
multimem_ld_reduce.rs
