ptx_parser/parser/instruction/
vset2.rs

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

ptx_parser/parser/instruction/
vset2.rs
