ptx_parser/parser/instruction/
vsh.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vop.dtype.atype.u32{.sat}.mode       d, a{.asel}, b{.bsel};
5//! vop.dtype.atype.u32{.sat}.mode.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vop.dtype.atype.u32{.sat}.mode  d.dsel, a{.asel}, b{.bsel}, c;
8//! vop   = { vshl, vshr };
9//! .dtype = .atype = { .u32, .s32 };
10//! .mode  = { .clamp, .wrap };
11//! .dsel  = .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
12//! .op2   = { .add, .min, .max };
13
14#![allow(unused)]
15
16use crate::lexer::PtxToken;
17use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
18use crate::r#type::common::*;
19
20pub mod section_0 {
21    use super::*;
22    use crate::r#type::instruction::vsh::section_0::*;
23
24    // ============================================================================
25    // Generated enum parsers
26    // ============================================================================
27
28    impl PtxParser for Asel {
29        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
30            // Try B0
31            {
32                let saved_pos = stream.position();
33                if stream.expect_string(".b0").is_ok() {
34                    return Ok(Asel::B0);
35                }
36                stream.set_position(saved_pos);
37            }
38            let saved_pos = stream.position();
39            // Try B1
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".b1").is_ok() {
43                    return Ok(Asel::B1);
44                }
45                stream.set_position(saved_pos);
46            }
47            stream.set_position(saved_pos);
48            let saved_pos = stream.position();
49            // Try B2
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".b2").is_ok() {
53                    return Ok(Asel::B2);
54                }
55                stream.set_position(saved_pos);
56            }
57            stream.set_position(saved_pos);
58            let saved_pos = stream.position();
59            // Try B3
60            {
61                let saved_pos = stream.position();
62                if stream.expect_string(".b3").is_ok() {
63                    return Ok(Asel::B3);
64                }
65                stream.set_position(saved_pos);
66            }
67            stream.set_position(saved_pos);
68            let saved_pos = stream.position();
69            // Try H0
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string(".h0").is_ok() {
73                    return Ok(Asel::H0);
74                }
75                stream.set_position(saved_pos);
76            }
77            stream.set_position(saved_pos);
78            let saved_pos = stream.position();
79            // Try H1
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".h1").is_ok() {
83                    return Ok(Asel::H1);
84                }
85                stream.set_position(saved_pos);
86            }
87            stream.set_position(saved_pos);
88            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
89            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
90            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
91            Err(crate::parser::unexpected_value(span, expected, found))
92        }
93    }
94
95    impl PtxParser for Atype {
96        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
97            // Try U32
98            {
99                let saved_pos = stream.position();
100                if stream.expect_string(".u32").is_ok() {
101                    return Ok(Atype::U32);
102                }
103                stream.set_position(saved_pos);
104            }
105            let saved_pos = stream.position();
106            // Try S32
107            {
108                let saved_pos = stream.position();
109                if stream.expect_string(".s32").is_ok() {
110                    return Ok(Atype::S32);
111                }
112                stream.set_position(saved_pos);
113            }
114            stream.set_position(saved_pos);
115            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
116            let expected = &[".u32", ".s32"];
117            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
118            Err(crate::parser::unexpected_value(span, expected, found))
119        }
120    }
121
122    impl PtxParser for Bsel {
123        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
124            // Try B0
125            {
126                let saved_pos = stream.position();
127                if stream.expect_string(".b0").is_ok() {
128                    return Ok(Bsel::B0);
129                }
130                stream.set_position(saved_pos);
131            }
132            let saved_pos = stream.position();
133            // Try B1
134            {
135                let saved_pos = stream.position();
136                if stream.expect_string(".b1").is_ok() {
137                    return Ok(Bsel::B1);
138                }
139                stream.set_position(saved_pos);
140            }
141            stream.set_position(saved_pos);
142            let saved_pos = stream.position();
143            // Try B2
144            {
145                let saved_pos = stream.position();
146                if stream.expect_string(".b2").is_ok() {
147                    return Ok(Bsel::B2);
148                }
149                stream.set_position(saved_pos);
150            }
151            stream.set_position(saved_pos);
152            let saved_pos = stream.position();
153            // Try B3
154            {
155                let saved_pos = stream.position();
156                if stream.expect_string(".b3").is_ok() {
157                    return Ok(Bsel::B3);
158                }
159                stream.set_position(saved_pos);
160            }
161            stream.set_position(saved_pos);
162            let saved_pos = stream.position();
163            // Try H0
164            {
165                let saved_pos = stream.position();
166                if stream.expect_string(".h0").is_ok() {
167                    return Ok(Bsel::H0);
168                }
169                stream.set_position(saved_pos);
170            }
171            stream.set_position(saved_pos);
172            let saved_pos = stream.position();
173            // Try H1
174            {
175                let saved_pos = stream.position();
176                if stream.expect_string(".h1").is_ok() {
177                    return Ok(Bsel::H1);
178                }
179                stream.set_position(saved_pos);
180            }
181            stream.set_position(saved_pos);
182            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
183            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
184            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
185            Err(crate::parser::unexpected_value(span, expected, found))
186        }
187    }
188
189    impl PtxParser for Dsel {
190        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
191            // Try B0
192            {
193                let saved_pos = stream.position();
194                if stream.expect_string(".b0").is_ok() {
195                    return Ok(Dsel::B0);
196                }
197                stream.set_position(saved_pos);
198            }
199            let saved_pos = stream.position();
200            // Try B1
201            {
202                let saved_pos = stream.position();
203                if stream.expect_string(".b1").is_ok() {
204                    return Ok(Dsel::B1);
205                }
206                stream.set_position(saved_pos);
207            }
208            stream.set_position(saved_pos);
209            let saved_pos = stream.position();
210            // Try B2
211            {
212                let saved_pos = stream.position();
213                if stream.expect_string(".b2").is_ok() {
214                    return Ok(Dsel::B2);
215                }
216                stream.set_position(saved_pos);
217            }
218            stream.set_position(saved_pos);
219            let saved_pos = stream.position();
220            // Try B3
221            {
222                let saved_pos = stream.position();
223                if stream.expect_string(".b3").is_ok() {
224                    return Ok(Dsel::B3);
225                }
226                stream.set_position(saved_pos);
227            }
228            stream.set_position(saved_pos);
229            let saved_pos = stream.position();
230            // Try H0
231            {
232                let saved_pos = stream.position();
233                if stream.expect_string(".h0").is_ok() {
234                    return Ok(Dsel::H0);
235                }
236                stream.set_position(saved_pos);
237            }
238            stream.set_position(saved_pos);
239            let saved_pos = stream.position();
240            // Try H1
241            {
242                let saved_pos = stream.position();
243                if stream.expect_string(".h1").is_ok() {
244                    return Ok(Dsel::H1);
245                }
246                stream.set_position(saved_pos);
247            }
248            stream.set_position(saved_pos);
249            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
250            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
251            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
252            Err(crate::parser::unexpected_value(span, expected, found))
253        }
254    }
255
256    impl PtxParser for Dtype {
257        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
258            // Try U32
259            {
260                let saved_pos = stream.position();
261                if stream.expect_string(".u32").is_ok() {
262                    return Ok(Dtype::U32);
263                }
264                stream.set_position(saved_pos);
265            }
266            let saved_pos = stream.position();
267            // Try S32
268            {
269                let saved_pos = stream.position();
270                if stream.expect_string(".s32").is_ok() {
271                    return Ok(Dtype::S32);
272                }
273                stream.set_position(saved_pos);
274            }
275            stream.set_position(saved_pos);
276            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
277            let expected = &[".u32", ".s32"];
278            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
279            Err(crate::parser::unexpected_value(span, expected, found))
280        }
281    }
282
283    impl PtxParser for Mode {
284        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
285            // Try Clamp
286            {
287                let saved_pos = stream.position();
288                if stream.expect_string(".clamp").is_ok() {
289                    return Ok(Mode::Clamp);
290                }
291                stream.set_position(saved_pos);
292            }
293            let saved_pos = stream.position();
294            // Try Wrap
295            {
296                let saved_pos = stream.position();
297                if stream.expect_string(".wrap").is_ok() {
298                    return Ok(Mode::Wrap);
299                }
300                stream.set_position(saved_pos);
301            }
302            stream.set_position(saved_pos);
303            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
304            let expected = &[".clamp", ".wrap"];
305            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
306            Err(crate::parser::unexpected_value(span, expected, found))
307        }
308    }
309
310    impl PtxParser for Op2 {
311        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
312            // Try Add
313            {
314                let saved_pos = stream.position();
315                if stream.expect_string(".add").is_ok() {
316                    return Ok(Op2::Add);
317                }
318                stream.set_position(saved_pos);
319            }
320            let saved_pos = stream.position();
321            // Try Min
322            {
323                let saved_pos = stream.position();
324                if stream.expect_string(".min").is_ok() {
325                    return Ok(Op2::Min);
326                }
327                stream.set_position(saved_pos);
328            }
329            stream.set_position(saved_pos);
330            let saved_pos = stream.position();
331            // Try Max
332            {
333                let saved_pos = stream.position();
334                if stream.expect_string(".max").is_ok() {
335                    return Ok(Op2::Max);
336                }
337                stream.set_position(saved_pos);
338            }
339            stream.set_position(saved_pos);
340            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
341            let expected = &[".add", ".min", ".max"];
342            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
343            Err(crate::parser::unexpected_value(span, expected, found))
344        }
345    }
346
347    impl PtxParser for VshlDtypeAtypeU32SatMode {
348        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
349            stream.expect_string("vshl")?;
350            let dtype = Dtype::parse(stream)?;
351            stream.expect_complete()?;
352            let atype = Atype::parse(stream)?;
353            stream.expect_complete()?;
354            stream.expect_string(".u32")?;
355            let u32 = ();
356            stream.expect_complete()?;
357            let saved_pos = stream.position();
358            let sat = stream.expect_string(".sat").is_ok();
359            if !sat {
360                stream.set_position(saved_pos);
361            }
362            stream.expect_complete()?;
363            let mode = Mode::parse(stream)?;
364            stream.expect_complete()?;
365            let d = GeneralOperand::parse(stream)?;
366            stream.expect_complete()?;
367            stream.expect(&PtxToken::Comma)?;
368            let a = GeneralOperand::parse(stream)?;
369            let saved_pos = stream.position();
370            let asel = match Asel::parse(stream) {
371                Ok(val) => Some(val),
372                Err(_) => {
373                    stream.set_position(saved_pos);
374                    None
375                }
376            };
377            stream.expect_complete()?;
378            stream.expect(&PtxToken::Comma)?;
379            let b = GeneralOperand::parse(stream)?;
380            let saved_pos = stream.position();
381            let bsel = match Bsel::parse(stream) {
382                Ok(val) => Some(val),
383                Err(_) => {
384                    stream.set_position(saved_pos);
385                    None
386                }
387            };
388            stream.expect_complete()?;
389            stream.expect_complete()?;
390            stream.expect(&PtxToken::Semicolon)?;
391            Ok(VshlDtypeAtypeU32SatMode {
392                dtype,
393                atype,
394                u32,
395                sat,
396                mode,
397                d,
398                a,
399                asel,
400                b,
401                bsel,
402            })
403        }
404    }
405
406
407    impl PtxParser for VshrDtypeAtypeU32SatMode {
408        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
409            stream.expect_string("vshr")?;
410            let dtype = Dtype::parse(stream)?;
411            stream.expect_complete()?;
412            let atype = Atype::parse(stream)?;
413            stream.expect_complete()?;
414            stream.expect_string(".u32")?;
415            let u32 = ();
416            stream.expect_complete()?;
417            let saved_pos = stream.position();
418            let sat = stream.expect_string(".sat").is_ok();
419            if !sat {
420                stream.set_position(saved_pos);
421            }
422            stream.expect_complete()?;
423            let mode = Mode::parse(stream)?;
424            stream.expect_complete()?;
425            let d = GeneralOperand::parse(stream)?;
426            stream.expect_complete()?;
427            stream.expect(&PtxToken::Comma)?;
428            let a = GeneralOperand::parse(stream)?;
429            let saved_pos = stream.position();
430            let asel = match Asel::parse(stream) {
431                Ok(val) => Some(val),
432                Err(_) => {
433                    stream.set_position(saved_pos);
434                    None
435                }
436            };
437            stream.expect_complete()?;
438            stream.expect(&PtxToken::Comma)?;
439            let b = GeneralOperand::parse(stream)?;
440            let saved_pos = stream.position();
441            let bsel = match Bsel::parse(stream) {
442                Ok(val) => Some(val),
443                Err(_) => {
444                    stream.set_position(saved_pos);
445                    None
446                }
447            };
448            stream.expect_complete()?;
449            stream.expect_complete()?;
450            stream.expect(&PtxToken::Semicolon)?;
451            Ok(VshrDtypeAtypeU32SatMode {
452                dtype,
453                atype,
454                u32,
455                sat,
456                mode,
457                d,
458                a,
459                asel,
460                b,
461                bsel,
462            })
463        }
464    }
465
466
467    impl PtxParser for VshlDtypeAtypeU32SatModeOp2 {
468        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
469            stream.expect_string("vshl")?;
470            let dtype = Dtype::parse(stream)?;
471            stream.expect_complete()?;
472            let atype = Atype::parse(stream)?;
473            stream.expect_complete()?;
474            stream.expect_string(".u32")?;
475            let u32 = ();
476            stream.expect_complete()?;
477            let saved_pos = stream.position();
478            let sat = stream.expect_string(".sat").is_ok();
479            if !sat {
480                stream.set_position(saved_pos);
481            }
482            stream.expect_complete()?;
483            let mode = Mode::parse(stream)?;
484            stream.expect_complete()?;
485            let op2 = Op2::parse(stream)?;
486            stream.expect_complete()?;
487            let d = GeneralOperand::parse(stream)?;
488            stream.expect_complete()?;
489            stream.expect(&PtxToken::Comma)?;
490            let a = GeneralOperand::parse(stream)?;
491            let saved_pos = stream.position();
492            let asel = match Asel::parse(stream) {
493                Ok(val) => Some(val),
494                Err(_) => {
495                    stream.set_position(saved_pos);
496                    None
497                }
498            };
499            stream.expect_complete()?;
500            stream.expect(&PtxToken::Comma)?;
501            let b = GeneralOperand::parse(stream)?;
502            let saved_pos = stream.position();
503            let bsel = match Bsel::parse(stream) {
504                Ok(val) => Some(val),
505                Err(_) => {
506                    stream.set_position(saved_pos);
507                    None
508                }
509            };
510            stream.expect_complete()?;
511            stream.expect(&PtxToken::Comma)?;
512            let c = GeneralOperand::parse(stream)?;
513            stream.expect_complete()?;
514            stream.expect_complete()?;
515            stream.expect(&PtxToken::Semicolon)?;
516            Ok(VshlDtypeAtypeU32SatModeOp2 {
517                dtype,
518                atype,
519                u32,
520                sat,
521                mode,
522                op2,
523                d,
524                a,
525                asel,
526                b,
527                bsel,
528                c,
529            })
530        }
531    }
532
533
534    impl PtxParser for VshrDtypeAtypeU32SatModeOp2 {
535        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
536            stream.expect_string("vshr")?;
537            let dtype = Dtype::parse(stream)?;
538            stream.expect_complete()?;
539            let atype = Atype::parse(stream)?;
540            stream.expect_complete()?;
541            stream.expect_string(".u32")?;
542            let u32 = ();
543            stream.expect_complete()?;
544            let saved_pos = stream.position();
545            let sat = stream.expect_string(".sat").is_ok();
546            if !sat {
547                stream.set_position(saved_pos);
548            }
549            stream.expect_complete()?;
550            let mode = Mode::parse(stream)?;
551            stream.expect_complete()?;
552            let op2 = Op2::parse(stream)?;
553            stream.expect_complete()?;
554            let d = GeneralOperand::parse(stream)?;
555            stream.expect_complete()?;
556            stream.expect(&PtxToken::Comma)?;
557            let a = GeneralOperand::parse(stream)?;
558            let saved_pos = stream.position();
559            let asel = match Asel::parse(stream) {
560                Ok(val) => Some(val),
561                Err(_) => {
562                    stream.set_position(saved_pos);
563                    None
564                }
565            };
566            stream.expect_complete()?;
567            stream.expect(&PtxToken::Comma)?;
568            let b = GeneralOperand::parse(stream)?;
569            let saved_pos = stream.position();
570            let bsel = match Bsel::parse(stream) {
571                Ok(val) => Some(val),
572                Err(_) => {
573                    stream.set_position(saved_pos);
574                    None
575                }
576            };
577            stream.expect_complete()?;
578            stream.expect(&PtxToken::Comma)?;
579            let c = GeneralOperand::parse(stream)?;
580            stream.expect_complete()?;
581            stream.expect_complete()?;
582            stream.expect(&PtxToken::Semicolon)?;
583            Ok(VshrDtypeAtypeU32SatModeOp2 {
584                dtype,
585                atype,
586                u32,
587                sat,
588                mode,
589                op2,
590                d,
591                a,
592                asel,
593                b,
594                bsel,
595                c,
596            })
597        }
598    }
599
600
601    impl PtxParser for VshlDtypeAtypeU32SatMode1 {
602        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
603            stream.expect_string("vshl")?;
604            let dtype = Dtype::parse(stream)?;
605            stream.expect_complete()?;
606            let atype = Atype::parse(stream)?;
607            stream.expect_complete()?;
608            stream.expect_string(".u32")?;
609            let u32 = ();
610            stream.expect_complete()?;
611            let saved_pos = stream.position();
612            let sat = stream.expect_string(".sat").is_ok();
613            if !sat {
614                stream.set_position(saved_pos);
615            }
616            stream.expect_complete()?;
617            let mode = Mode::parse(stream)?;
618            stream.expect_complete()?;
619            let d = GeneralOperand::parse(stream)?;
620            let dsel = Dsel::parse(stream)?;
621            stream.expect_complete()?;
622            stream.expect(&PtxToken::Comma)?;
623            let a = GeneralOperand::parse(stream)?;
624            let saved_pos = stream.position();
625            let asel = match Asel::parse(stream) {
626                Ok(val) => Some(val),
627                Err(_) => {
628                    stream.set_position(saved_pos);
629                    None
630                }
631            };
632            stream.expect_complete()?;
633            stream.expect(&PtxToken::Comma)?;
634            let b = GeneralOperand::parse(stream)?;
635            let saved_pos = stream.position();
636            let bsel = match Bsel::parse(stream) {
637                Ok(val) => Some(val),
638                Err(_) => {
639                    stream.set_position(saved_pos);
640                    None
641                }
642            };
643            stream.expect_complete()?;
644            stream.expect(&PtxToken::Comma)?;
645            let c = GeneralOperand::parse(stream)?;
646            stream.expect_complete()?;
647            stream.expect_complete()?;
648            stream.expect(&PtxToken::Semicolon)?;
649            Ok(VshlDtypeAtypeU32SatMode1 {
650                dtype,
651                atype,
652                u32,
653                sat,
654                mode,
655                d,
656                dsel,
657                a,
658                asel,
659                b,
660                bsel,
661                c,
662            })
663        }
664    }
665
666
667    impl PtxParser for VshrDtypeAtypeU32SatMode1 {
668        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
669            stream.expect_string("vshr")?;
670            let dtype = Dtype::parse(stream)?;
671            stream.expect_complete()?;
672            let atype = Atype::parse(stream)?;
673            stream.expect_complete()?;
674            stream.expect_string(".u32")?;
675            let u32 = ();
676            stream.expect_complete()?;
677            let saved_pos = stream.position();
678            let sat = stream.expect_string(".sat").is_ok();
679            if !sat {
680                stream.set_position(saved_pos);
681            }
682            stream.expect_complete()?;
683            let mode = Mode::parse(stream)?;
684            stream.expect_complete()?;
685            let d = GeneralOperand::parse(stream)?;
686            let dsel = Dsel::parse(stream)?;
687            stream.expect_complete()?;
688            stream.expect(&PtxToken::Comma)?;
689            let a = GeneralOperand::parse(stream)?;
690            let saved_pos = stream.position();
691            let asel = match Asel::parse(stream) {
692                Ok(val) => Some(val),
693                Err(_) => {
694                    stream.set_position(saved_pos);
695                    None
696                }
697            };
698            stream.expect_complete()?;
699            stream.expect(&PtxToken::Comma)?;
700            let b = GeneralOperand::parse(stream)?;
701            let saved_pos = stream.position();
702            let bsel = match Bsel::parse(stream) {
703                Ok(val) => Some(val),
704                Err(_) => {
705                    stream.set_position(saved_pos);
706                    None
707                }
708            };
709            stream.expect_complete()?;
710            stream.expect(&PtxToken::Comma)?;
711            let c = GeneralOperand::parse(stream)?;
712            stream.expect_complete()?;
713            stream.expect_complete()?;
714            stream.expect(&PtxToken::Semicolon)?;
715            Ok(VshrDtypeAtypeU32SatMode1 {
716                dtype,
717                atype,
718                u32,
719                sat,
720                mode,
721                d,
722                dsel,
723                a,
724                asel,
725                b,
726                bsel,
727                c,
728            })
729        }
730    }
731
732
733}
734
ptx_parser/parser/instruction/vsh.rs

ptx_parser/parser/instruction/
vsh.rs
