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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
189            let expected = &[".h00", ".h01", ".h02", ".h03", ".h10", ".h11", ".h12", ".h13", ".h20", ".h21", ".h22", ".h23", ".h30", ".h31", ".h32", ".h33"];
190            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
191            Err(crate::parser::unexpected_value(span, expected, found))
192        }
193    }
194
195    impl PtxParser for Atype {
196        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
197            // Try U32
198            {
199                let saved_pos = stream.position();
200                if stream.expect_string(".u32").is_ok() {
201                    return Ok(Atype::U32);
202                }
203                stream.set_position(saved_pos);
204            }
205            let saved_pos = stream.position();
206            // Try S32
207            {
208                let saved_pos = stream.position();
209                if stream.expect_string(".s32").is_ok() {
210                    return Ok(Atype::S32);
211                }
212                stream.set_position(saved_pos);
213            }
214            stream.set_position(saved_pos);
215            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
216            let expected = &[".u32", ".s32"];
217            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
218            Err(crate::parser::unexpected_value(span, expected, found))
219        }
220    }
221
222    impl PtxParser for Bsel {
223        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
224            // Try H00
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".h00").is_ok() {
228                    return Ok(Bsel::H00);
229                }
230                stream.set_position(saved_pos);
231            }
232            let saved_pos = stream.position();
233            // Try H01
234            {
235                let saved_pos = stream.position();
236                if stream.expect_string(".h01").is_ok() {
237                    return Ok(Bsel::H01);
238                }
239                stream.set_position(saved_pos);
240            }
241            stream.set_position(saved_pos);
242            let saved_pos = stream.position();
243            // Try H02
244            {
245                let saved_pos = stream.position();
246                if stream.expect_string(".h02").is_ok() {
247                    return Ok(Bsel::H02);
248                }
249                stream.set_position(saved_pos);
250            }
251            stream.set_position(saved_pos);
252            let saved_pos = stream.position();
253            // Try H03
254            {
255                let saved_pos = stream.position();
256                if stream.expect_string(".h03").is_ok() {
257                    return Ok(Bsel::H03);
258                }
259                stream.set_position(saved_pos);
260            }
261            stream.set_position(saved_pos);
262            let saved_pos = stream.position();
263            // Try H10
264            {
265                let saved_pos = stream.position();
266                if stream.expect_string(".h10").is_ok() {
267                    return Ok(Bsel::H10);
268                }
269                stream.set_position(saved_pos);
270            }
271            stream.set_position(saved_pos);
272            let saved_pos = stream.position();
273            // Try H11
274            {
275                let saved_pos = stream.position();
276                if stream.expect_string(".h11").is_ok() {
277                    return Ok(Bsel::H11);
278                }
279                stream.set_position(saved_pos);
280            }
281            stream.set_position(saved_pos);
282            let saved_pos = stream.position();
283            // Try H12
284            {
285                let saved_pos = stream.position();
286                if stream.expect_string(".h12").is_ok() {
287                    return Ok(Bsel::H12);
288                }
289                stream.set_position(saved_pos);
290            }
291            stream.set_position(saved_pos);
292            let saved_pos = stream.position();
293            // Try H13
294            {
295                let saved_pos = stream.position();
296                if stream.expect_string(".h13").is_ok() {
297                    return Ok(Bsel::H13);
298                }
299                stream.set_position(saved_pos);
300            }
301            stream.set_position(saved_pos);
302            let saved_pos = stream.position();
303            // Try H20
304            {
305                let saved_pos = stream.position();
306                if stream.expect_string(".h20").is_ok() {
307                    return Ok(Bsel::H20);
308                }
309                stream.set_position(saved_pos);
310            }
311            stream.set_position(saved_pos);
312            let saved_pos = stream.position();
313            // Try H21
314            {
315                let saved_pos = stream.position();
316                if stream.expect_string(".h21").is_ok() {
317                    return Ok(Bsel::H21);
318                }
319                stream.set_position(saved_pos);
320            }
321            stream.set_position(saved_pos);
322            let saved_pos = stream.position();
323            // Try H22
324            {
325                let saved_pos = stream.position();
326                if stream.expect_string(".h22").is_ok() {
327                    return Ok(Bsel::H22);
328                }
329                stream.set_position(saved_pos);
330            }
331            stream.set_position(saved_pos);
332            let saved_pos = stream.position();
333            // Try H23
334            {
335                let saved_pos = stream.position();
336                if stream.expect_string(".h23").is_ok() {
337                    return Ok(Bsel::H23);
338                }
339                stream.set_position(saved_pos);
340            }
341            stream.set_position(saved_pos);
342            let saved_pos = stream.position();
343            // Try H30
344            {
345                let saved_pos = stream.position();
346                if stream.expect_string(".h30").is_ok() {
347                    return Ok(Bsel::H30);
348                }
349                stream.set_position(saved_pos);
350            }
351            stream.set_position(saved_pos);
352            let saved_pos = stream.position();
353            // Try H31
354            {
355                let saved_pos = stream.position();
356                if stream.expect_string(".h31").is_ok() {
357                    return Ok(Bsel::H31);
358                }
359                stream.set_position(saved_pos);
360            }
361            stream.set_position(saved_pos);
362            let saved_pos = stream.position();
363            // Try H32
364            {
365                let saved_pos = stream.position();
366                if stream.expect_string(".h32").is_ok() {
367                    return Ok(Bsel::H32);
368                }
369                stream.set_position(saved_pos);
370            }
371            stream.set_position(saved_pos);
372            let saved_pos = stream.position();
373            // Try H33
374            {
375                let saved_pos = stream.position();
376                if stream.expect_string(".h33").is_ok() {
377                    return Ok(Bsel::H33);
378                }
379                stream.set_position(saved_pos);
380            }
381            stream.set_position(saved_pos);
382            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
383            let expected = &[".h00", ".h01", ".h02", ".h03", ".h10", ".h11", ".h12", ".h13", ".h20", ".h21", ".h22", ".h23", ".h30", ".h31", ".h32", ".h33"];
384            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
385            Err(crate::parser::unexpected_value(span, expected, found))
386        }
387    }
388
389    impl PtxParser for Btype {
390        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
391            // Try U32
392            {
393                let saved_pos = stream.position();
394                if stream.expect_string(".u32").is_ok() {
395                    return Ok(Btype::U32);
396                }
397                stream.set_position(saved_pos);
398            }
399            let saved_pos = stream.position();
400            // Try S32
401            {
402                let saved_pos = stream.position();
403                if stream.expect_string(".s32").is_ok() {
404                    return Ok(Btype::S32);
405                }
406                stream.set_position(saved_pos);
407            }
408            stream.set_position(saved_pos);
409            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
410            let expected = &[".u32", ".s32"];
411            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
412            Err(crate::parser::unexpected_value(span, expected, found))
413        }
414    }
415
416    impl PtxParser for Cmp {
417        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
418            // Try Eq
419            {
420                let saved_pos = stream.position();
421                if stream.expect_string(".eq").is_ok() {
422                    return Ok(Cmp::Eq);
423                }
424                stream.set_position(saved_pos);
425            }
426            let saved_pos = stream.position();
427            // Try Ne
428            {
429                let saved_pos = stream.position();
430                if stream.expect_string(".ne").is_ok() {
431                    return Ok(Cmp::Ne);
432                }
433                stream.set_position(saved_pos);
434            }
435            stream.set_position(saved_pos);
436            let saved_pos = stream.position();
437            // Try Lt
438            {
439                let saved_pos = stream.position();
440                if stream.expect_string(".lt").is_ok() {
441                    return Ok(Cmp::Lt);
442                }
443                stream.set_position(saved_pos);
444            }
445            stream.set_position(saved_pos);
446            let saved_pos = stream.position();
447            // Try Le
448            {
449                let saved_pos = stream.position();
450                if stream.expect_string(".le").is_ok() {
451                    return Ok(Cmp::Le);
452                }
453                stream.set_position(saved_pos);
454            }
455            stream.set_position(saved_pos);
456            let saved_pos = stream.position();
457            // Try Gt
458            {
459                let saved_pos = stream.position();
460                if stream.expect_string(".gt").is_ok() {
461                    return Ok(Cmp::Gt);
462                }
463                stream.set_position(saved_pos);
464            }
465            stream.set_position(saved_pos);
466            let saved_pos = stream.position();
467            // Try Ge
468            {
469                let saved_pos = stream.position();
470                if stream.expect_string(".ge").is_ok() {
471                    return Ok(Cmp::Ge);
472                }
473                stream.set_position(saved_pos);
474            }
475            stream.set_position(saved_pos);
476            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
477            let expected = &[".eq", ".ne", ".lt", ".le", ".gt", ".ge"];
478            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
479            Err(crate::parser::unexpected_value(span, expected, found))
480        }
481    }
482
483    impl PtxParser for Mask {
484        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
485            // Try H10
486            {
487                let saved_pos = stream.position();
488                if stream.expect_string(".h10").is_ok() {
489                    return Ok(Mask::H10);
490                }
491                stream.set_position(saved_pos);
492            }
493            let saved_pos = stream.position();
494            // Try H0
495            {
496                let saved_pos = stream.position();
497                if stream.expect_string(".h0").is_ok() {
498                    return Ok(Mask::H0);
499                }
500                stream.set_position(saved_pos);
501            }
502            stream.set_position(saved_pos);
503            let saved_pos = stream.position();
504            // Try H1
505            {
506                let saved_pos = stream.position();
507                if stream.expect_string(".h1").is_ok() {
508                    return Ok(Mask::H1);
509                }
510                stream.set_position(saved_pos);
511            }
512            stream.set_position(saved_pos);
513            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
514            let expected = &[".h10", ".h0", ".h1"];
515            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
516            Err(crate::parser::unexpected_value(span, expected, found))
517        }
518    }
519
520    impl PtxParser for Vset2AtypeBtypeCmp {
521        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
522            stream.expect_string("vset2")?;
523            let atype = Atype::parse(stream)?;
524            stream.expect_complete()?;
525            let btype = Btype::parse(stream)?;
526            stream.expect_complete()?;
527            let cmp = Cmp::parse(stream)?;
528            stream.expect_complete()?;
529            let d = GeneralOperand::parse(stream)?;
530            let saved_pos = stream.position();
531            let mask = match Mask::parse(stream) {
532                Ok(val) => Some(val),
533                Err(_) => {
534                    stream.set_position(saved_pos);
535                    None
536                }
537            };
538            stream.expect_complete()?;
539            stream.expect(&PtxToken::Comma)?;
540            let a = GeneralOperand::parse(stream)?;
541            let saved_pos = stream.position();
542            let asel = match Asel::parse(stream) {
543                Ok(val) => Some(val),
544                Err(_) => {
545                    stream.set_position(saved_pos);
546                    None
547                }
548            };
549            stream.expect_complete()?;
550            stream.expect(&PtxToken::Comma)?;
551            let b = GeneralOperand::parse(stream)?;
552            let saved_pos = stream.position();
553            let bsel = match Bsel::parse(stream) {
554                Ok(val) => Some(val),
555                Err(_) => {
556                    stream.set_position(saved_pos);
557                    None
558                }
559            };
560            stream.expect_complete()?;
561            stream.expect(&PtxToken::Comma)?;
562            let c = GeneralOperand::parse(stream)?;
563            stream.expect_complete()?;
564            stream.expect_complete()?;
565            stream.expect(&PtxToken::Semicolon)?;
566            Ok(Vset2AtypeBtypeCmp {
567                atype,
568                btype,
569                cmp,
570                d,
571                mask,
572                a,
573                asel,
574                b,
575                bsel,
576                c,
577            })
578        }
579    }
580
581
582    impl PtxParser for Vset2AtypeBtypeCmpAdd {
583        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
584            stream.expect_string("vset2")?;
585            let atype = Atype::parse(stream)?;
586            stream.expect_complete()?;
587            let btype = Btype::parse(stream)?;
588            stream.expect_complete()?;
589            let cmp = Cmp::parse(stream)?;
590            stream.expect_complete()?;
591            stream.expect_string(".add")?;
592            let add = ();
593            stream.expect_complete()?;
594            let d = GeneralOperand::parse(stream)?;
595            let saved_pos = stream.position();
596            let mask = match Mask::parse(stream) {
597                Ok(val) => Some(val),
598                Err(_) => {
599                    stream.set_position(saved_pos);
600                    None
601                }
602            };
603            stream.expect_complete()?;
604            stream.expect(&PtxToken::Comma)?;
605            let a = GeneralOperand::parse(stream)?;
606            let saved_pos = stream.position();
607            let asel = match Asel::parse(stream) {
608                Ok(val) => Some(val),
609                Err(_) => {
610                    stream.set_position(saved_pos);
611                    None
612                }
613            };
614            stream.expect_complete()?;
615            stream.expect(&PtxToken::Comma)?;
616            let b = GeneralOperand::parse(stream)?;
617            let saved_pos = stream.position();
618            let bsel = match Bsel::parse(stream) {
619                Ok(val) => Some(val),
620                Err(_) => {
621                    stream.set_position(saved_pos);
622                    None
623                }
624            };
625            stream.expect_complete()?;
626            stream.expect(&PtxToken::Comma)?;
627            let c = GeneralOperand::parse(stream)?;
628            stream.expect_complete()?;
629            stream.expect_complete()?;
630            stream.expect(&PtxToken::Semicolon)?;
631            Ok(Vset2AtypeBtypeCmpAdd {
632                atype,
633                btype,
634                cmp,
635                add,
636                d,
637                mask,
638                a,
639                asel,
640                b,
641                bsel,
642                c,
643            })
644        }
645    }
646
647
648}
649
ptx_parser/parser/instruction/vset2.rs

ptx_parser/parser/instruction/
vset2.rs
