ptx_parser/parser/instruction/
vop2.rs

1//! Original PTX specification:
2//!
3//! // SIMD instruction with secondary SIMD merge operation
4//! vop2.dtype.atype.btype{.sat}  d{.mask}, a{.asel}, b{.bsel}, c;
5//! // SIMD instruction with secondary accumulate operation
6//! vop2.dtype.atype.btype.add  d{.mask}, a{.asel}, b{.bsel}, c;
7//! vop2  = { vadd2, vsub2, vavrg2, vabsdiff2, vmin2, vmax2 };
8//! .dtype = .atype = .btype = { .u32, .s32 };
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 }; 
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::vop2::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 Dtype {
417        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
418            // Try U32
419            {
420                let saved_pos = stream.position();
421                if stream.expect_string(".u32").is_ok() {
422                    return Ok(Dtype::U32);
423                }
424                stream.set_position(saved_pos);
425            }
426            let saved_pos = stream.position();
427            // Try S32
428            {
429                let saved_pos = stream.position();
430                if stream.expect_string(".s32").is_ok() {
431                    return Ok(Dtype::S32);
432                }
433                stream.set_position(saved_pos);
434            }
435            stream.set_position(saved_pos);
436            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
437            let expected = &[".u32", ".s32"];
438            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
439            Err(crate::parser::unexpected_value(span, expected, found))
440        }
441    }
442
443    impl PtxParser for Mask {
444        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
445            // Try H10
446            {
447                let saved_pos = stream.position();
448                if stream.expect_string(".h10").is_ok() {
449                    return Ok(Mask::H10);
450                }
451                stream.set_position(saved_pos);
452            }
453            let saved_pos = stream.position();
454            // Try H0
455            {
456                let saved_pos = stream.position();
457                if stream.expect_string(".h0").is_ok() {
458                    return Ok(Mask::H0);
459                }
460                stream.set_position(saved_pos);
461            }
462            stream.set_position(saved_pos);
463            let saved_pos = stream.position();
464            // Try H1
465            {
466                let saved_pos = stream.position();
467                if stream.expect_string(".h1").is_ok() {
468                    return Ok(Mask::H1);
469                }
470                stream.set_position(saved_pos);
471            }
472            stream.set_position(saved_pos);
473            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
474            let expected = &[".h10", ".h0", ".h1"];
475            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
476            Err(crate::parser::unexpected_value(span, expected, found))
477        }
478    }
479
480    impl PtxParser for Vadd2DtypeAtypeBtypeSat {
481        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
482            stream.expect_string("vadd2")?;
483            let dtype = Dtype::parse(stream)?;
484            stream.expect_complete()?;
485            let atype = Atype::parse(stream)?;
486            stream.expect_complete()?;
487            let btype = Btype::parse(stream)?;
488            stream.expect_complete()?;
489            let saved_pos = stream.position();
490            let sat = stream.expect_string(".sat").is_ok();
491            if !sat {
492                stream.set_position(saved_pos);
493            }
494            stream.expect_complete()?;
495            let d = GeneralOperand::parse(stream)?;
496            let saved_pos = stream.position();
497            let mask = match Mask::parse(stream) {
498                Ok(val) => Some(val),
499                Err(_) => {
500                    stream.set_position(saved_pos);
501                    None
502                }
503            };
504            stream.expect_complete()?;
505            stream.expect(&PtxToken::Comma)?;
506            let a = GeneralOperand::parse(stream)?;
507            let saved_pos = stream.position();
508            let asel = match Asel::parse(stream) {
509                Ok(val) => Some(val),
510                Err(_) => {
511                    stream.set_position(saved_pos);
512                    None
513                }
514            };
515            stream.expect_complete()?;
516            stream.expect(&PtxToken::Comma)?;
517            let b = GeneralOperand::parse(stream)?;
518            let saved_pos = stream.position();
519            let bsel = match Bsel::parse(stream) {
520                Ok(val) => Some(val),
521                Err(_) => {
522                    stream.set_position(saved_pos);
523                    None
524                }
525            };
526            stream.expect_complete()?;
527            stream.expect(&PtxToken::Comma)?;
528            let c = GeneralOperand::parse(stream)?;
529            stream.expect_complete()?;
530            stream.expect_complete()?;
531            stream.expect(&PtxToken::Semicolon)?;
532            Ok(Vadd2DtypeAtypeBtypeSat {
533                dtype,
534                atype,
535                btype,
536                sat,
537                d,
538                mask,
539                a,
540                asel,
541                b,
542                bsel,
543                c,
544            })
545        }
546    }
547
548
549    impl PtxParser for Vsub2DtypeAtypeBtypeSat {
550        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
551            stream.expect_string("vsub2")?;
552            let dtype = Dtype::parse(stream)?;
553            stream.expect_complete()?;
554            let atype = Atype::parse(stream)?;
555            stream.expect_complete()?;
556            let btype = Btype::parse(stream)?;
557            stream.expect_complete()?;
558            let saved_pos = stream.position();
559            let sat = stream.expect_string(".sat").is_ok();
560            if !sat {
561                stream.set_position(saved_pos);
562            }
563            stream.expect_complete()?;
564            let d = GeneralOperand::parse(stream)?;
565            let saved_pos = stream.position();
566            let mask = match Mask::parse(stream) {
567                Ok(val) => Some(val),
568                Err(_) => {
569                    stream.set_position(saved_pos);
570                    None
571                }
572            };
573            stream.expect_complete()?;
574            stream.expect(&PtxToken::Comma)?;
575            let a = GeneralOperand::parse(stream)?;
576            let saved_pos = stream.position();
577            let asel = match Asel::parse(stream) {
578                Ok(val) => Some(val),
579                Err(_) => {
580                    stream.set_position(saved_pos);
581                    None
582                }
583            };
584            stream.expect_complete()?;
585            stream.expect(&PtxToken::Comma)?;
586            let b = GeneralOperand::parse(stream)?;
587            let saved_pos = stream.position();
588            let bsel = match Bsel::parse(stream) {
589                Ok(val) => Some(val),
590                Err(_) => {
591                    stream.set_position(saved_pos);
592                    None
593                }
594            };
595            stream.expect_complete()?;
596            stream.expect(&PtxToken::Comma)?;
597            let c = GeneralOperand::parse(stream)?;
598            stream.expect_complete()?;
599            stream.expect_complete()?;
600            stream.expect(&PtxToken::Semicolon)?;
601            Ok(Vsub2DtypeAtypeBtypeSat {
602                dtype,
603                atype,
604                btype,
605                sat,
606                d,
607                mask,
608                a,
609                asel,
610                b,
611                bsel,
612                c,
613            })
614        }
615    }
616
617
618    impl PtxParser for Vavrg2DtypeAtypeBtypeSat {
619        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
620            stream.expect_string("vavrg2")?;
621            let dtype = Dtype::parse(stream)?;
622            stream.expect_complete()?;
623            let atype = Atype::parse(stream)?;
624            stream.expect_complete()?;
625            let btype = Btype::parse(stream)?;
626            stream.expect_complete()?;
627            let saved_pos = stream.position();
628            let sat = stream.expect_string(".sat").is_ok();
629            if !sat {
630                stream.set_position(saved_pos);
631            }
632            stream.expect_complete()?;
633            let d = GeneralOperand::parse(stream)?;
634            let saved_pos = stream.position();
635            let mask = match Mask::parse(stream) {
636                Ok(val) => Some(val),
637                Err(_) => {
638                    stream.set_position(saved_pos);
639                    None
640                }
641            };
642            stream.expect_complete()?;
643            stream.expect(&PtxToken::Comma)?;
644            let a = GeneralOperand::parse(stream)?;
645            let saved_pos = stream.position();
646            let asel = match Asel::parse(stream) {
647                Ok(val) => Some(val),
648                Err(_) => {
649                    stream.set_position(saved_pos);
650                    None
651                }
652            };
653            stream.expect_complete()?;
654            stream.expect(&PtxToken::Comma)?;
655            let b = GeneralOperand::parse(stream)?;
656            let saved_pos = stream.position();
657            let bsel = match Bsel::parse(stream) {
658                Ok(val) => Some(val),
659                Err(_) => {
660                    stream.set_position(saved_pos);
661                    None
662                }
663            };
664            stream.expect_complete()?;
665            stream.expect(&PtxToken::Comma)?;
666            let c = GeneralOperand::parse(stream)?;
667            stream.expect_complete()?;
668            stream.expect_complete()?;
669            stream.expect(&PtxToken::Semicolon)?;
670            Ok(Vavrg2DtypeAtypeBtypeSat {
671                dtype,
672                atype,
673                btype,
674                sat,
675                d,
676                mask,
677                a,
678                asel,
679                b,
680                bsel,
681                c,
682            })
683        }
684    }
685
686
687    impl PtxParser for Vabsdiff2DtypeAtypeBtypeSat {
688        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
689            stream.expect_string("vabsdiff2")?;
690            let dtype = Dtype::parse(stream)?;
691            stream.expect_complete()?;
692            let atype = Atype::parse(stream)?;
693            stream.expect_complete()?;
694            let btype = Btype::parse(stream)?;
695            stream.expect_complete()?;
696            let saved_pos = stream.position();
697            let sat = stream.expect_string(".sat").is_ok();
698            if !sat {
699                stream.set_position(saved_pos);
700            }
701            stream.expect_complete()?;
702            let d = GeneralOperand::parse(stream)?;
703            let saved_pos = stream.position();
704            let mask = match Mask::parse(stream) {
705                Ok(val) => Some(val),
706                Err(_) => {
707                    stream.set_position(saved_pos);
708                    None
709                }
710            };
711            stream.expect_complete()?;
712            stream.expect(&PtxToken::Comma)?;
713            let a = GeneralOperand::parse(stream)?;
714            let saved_pos = stream.position();
715            let asel = match Asel::parse(stream) {
716                Ok(val) => Some(val),
717                Err(_) => {
718                    stream.set_position(saved_pos);
719                    None
720                }
721            };
722            stream.expect_complete()?;
723            stream.expect(&PtxToken::Comma)?;
724            let b = GeneralOperand::parse(stream)?;
725            let saved_pos = stream.position();
726            let bsel = match Bsel::parse(stream) {
727                Ok(val) => Some(val),
728                Err(_) => {
729                    stream.set_position(saved_pos);
730                    None
731                }
732            };
733            stream.expect_complete()?;
734            stream.expect(&PtxToken::Comma)?;
735            let c = GeneralOperand::parse(stream)?;
736            stream.expect_complete()?;
737            stream.expect_complete()?;
738            stream.expect(&PtxToken::Semicolon)?;
739            Ok(Vabsdiff2DtypeAtypeBtypeSat {
740                dtype,
741                atype,
742                btype,
743                sat,
744                d,
745                mask,
746                a,
747                asel,
748                b,
749                bsel,
750                c,
751            })
752        }
753    }
754
755
756    impl PtxParser for Vmin2DtypeAtypeBtypeSat {
757        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
758            stream.expect_string("vmin2")?;
759            let dtype = Dtype::parse(stream)?;
760            stream.expect_complete()?;
761            let atype = Atype::parse(stream)?;
762            stream.expect_complete()?;
763            let btype = Btype::parse(stream)?;
764            stream.expect_complete()?;
765            let saved_pos = stream.position();
766            let sat = stream.expect_string(".sat").is_ok();
767            if !sat {
768                stream.set_position(saved_pos);
769            }
770            stream.expect_complete()?;
771            let d = GeneralOperand::parse(stream)?;
772            let saved_pos = stream.position();
773            let mask = match Mask::parse(stream) {
774                Ok(val) => Some(val),
775                Err(_) => {
776                    stream.set_position(saved_pos);
777                    None
778                }
779            };
780            stream.expect_complete()?;
781            stream.expect(&PtxToken::Comma)?;
782            let a = GeneralOperand::parse(stream)?;
783            let saved_pos = stream.position();
784            let asel = match Asel::parse(stream) {
785                Ok(val) => Some(val),
786                Err(_) => {
787                    stream.set_position(saved_pos);
788                    None
789                }
790            };
791            stream.expect_complete()?;
792            stream.expect(&PtxToken::Comma)?;
793            let b = GeneralOperand::parse(stream)?;
794            let saved_pos = stream.position();
795            let bsel = match Bsel::parse(stream) {
796                Ok(val) => Some(val),
797                Err(_) => {
798                    stream.set_position(saved_pos);
799                    None
800                }
801            };
802            stream.expect_complete()?;
803            stream.expect(&PtxToken::Comma)?;
804            let c = GeneralOperand::parse(stream)?;
805            stream.expect_complete()?;
806            stream.expect_complete()?;
807            stream.expect(&PtxToken::Semicolon)?;
808            Ok(Vmin2DtypeAtypeBtypeSat {
809                dtype,
810                atype,
811                btype,
812                sat,
813                d,
814                mask,
815                a,
816                asel,
817                b,
818                bsel,
819                c,
820            })
821        }
822    }
823
824
825    impl PtxParser for Vmax2DtypeAtypeBtypeSat {
826        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
827            stream.expect_string("vmax2")?;
828            let dtype = Dtype::parse(stream)?;
829            stream.expect_complete()?;
830            let atype = Atype::parse(stream)?;
831            stream.expect_complete()?;
832            let btype = Btype::parse(stream)?;
833            stream.expect_complete()?;
834            let saved_pos = stream.position();
835            let sat = stream.expect_string(".sat").is_ok();
836            if !sat {
837                stream.set_position(saved_pos);
838            }
839            stream.expect_complete()?;
840            let d = GeneralOperand::parse(stream)?;
841            let saved_pos = stream.position();
842            let mask = match Mask::parse(stream) {
843                Ok(val) => Some(val),
844                Err(_) => {
845                    stream.set_position(saved_pos);
846                    None
847                }
848            };
849            stream.expect_complete()?;
850            stream.expect(&PtxToken::Comma)?;
851            let a = GeneralOperand::parse(stream)?;
852            let saved_pos = stream.position();
853            let asel = match Asel::parse(stream) {
854                Ok(val) => Some(val),
855                Err(_) => {
856                    stream.set_position(saved_pos);
857                    None
858                }
859            };
860            stream.expect_complete()?;
861            stream.expect(&PtxToken::Comma)?;
862            let b = GeneralOperand::parse(stream)?;
863            let saved_pos = stream.position();
864            let bsel = match Bsel::parse(stream) {
865                Ok(val) => Some(val),
866                Err(_) => {
867                    stream.set_position(saved_pos);
868                    None
869                }
870            };
871            stream.expect_complete()?;
872            stream.expect(&PtxToken::Comma)?;
873            let c = GeneralOperand::parse(stream)?;
874            stream.expect_complete()?;
875            stream.expect_complete()?;
876            stream.expect(&PtxToken::Semicolon)?;
877            Ok(Vmax2DtypeAtypeBtypeSat {
878                dtype,
879                atype,
880                btype,
881                sat,
882                d,
883                mask,
884                a,
885                asel,
886                b,
887                bsel,
888                c,
889            })
890        }
891    }
892
893
894    impl PtxParser for Vadd2DtypeAtypeBtypeAdd {
895        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
896            stream.expect_string("vadd2")?;
897            let dtype = Dtype::parse(stream)?;
898            stream.expect_complete()?;
899            let atype = Atype::parse(stream)?;
900            stream.expect_complete()?;
901            let btype = Btype::parse(stream)?;
902            stream.expect_complete()?;
903            stream.expect_string(".add")?;
904            let add = ();
905            stream.expect_complete()?;
906            let d = GeneralOperand::parse(stream)?;
907            let saved_pos = stream.position();
908            let mask = match Mask::parse(stream) {
909                Ok(val) => Some(val),
910                Err(_) => {
911                    stream.set_position(saved_pos);
912                    None
913                }
914            };
915            stream.expect_complete()?;
916            stream.expect(&PtxToken::Comma)?;
917            let a = GeneralOperand::parse(stream)?;
918            let saved_pos = stream.position();
919            let asel = match Asel::parse(stream) {
920                Ok(val) => Some(val),
921                Err(_) => {
922                    stream.set_position(saved_pos);
923                    None
924                }
925            };
926            stream.expect_complete()?;
927            stream.expect(&PtxToken::Comma)?;
928            let b = GeneralOperand::parse(stream)?;
929            let saved_pos = stream.position();
930            let bsel = match Bsel::parse(stream) {
931                Ok(val) => Some(val),
932                Err(_) => {
933                    stream.set_position(saved_pos);
934                    None
935                }
936            };
937            stream.expect_complete()?;
938            stream.expect(&PtxToken::Comma)?;
939            let c = GeneralOperand::parse(stream)?;
940            stream.expect_complete()?;
941            stream.expect_complete()?;
942            stream.expect(&PtxToken::Semicolon)?;
943            Ok(Vadd2DtypeAtypeBtypeAdd {
944                dtype,
945                atype,
946                btype,
947                add,
948                d,
949                mask,
950                a,
951                asel,
952                b,
953                bsel,
954                c,
955            })
956        }
957    }
958
959
960    impl PtxParser for Vsub2DtypeAtypeBtypeAdd {
961        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
962            stream.expect_string("vsub2")?;
963            let dtype = Dtype::parse(stream)?;
964            stream.expect_complete()?;
965            let atype = Atype::parse(stream)?;
966            stream.expect_complete()?;
967            let btype = Btype::parse(stream)?;
968            stream.expect_complete()?;
969            stream.expect_string(".add")?;
970            let add = ();
971            stream.expect_complete()?;
972            let d = GeneralOperand::parse(stream)?;
973            let saved_pos = stream.position();
974            let mask = match Mask::parse(stream) {
975                Ok(val) => Some(val),
976                Err(_) => {
977                    stream.set_position(saved_pos);
978                    None
979                }
980            };
981            stream.expect_complete()?;
982            stream.expect(&PtxToken::Comma)?;
983            let a = GeneralOperand::parse(stream)?;
984            let saved_pos = stream.position();
985            let asel = match Asel::parse(stream) {
986                Ok(val) => Some(val),
987                Err(_) => {
988                    stream.set_position(saved_pos);
989                    None
990                }
991            };
992            stream.expect_complete()?;
993            stream.expect(&PtxToken::Comma)?;
994            let b = GeneralOperand::parse(stream)?;
995            let saved_pos = stream.position();
996            let bsel = match Bsel::parse(stream) {
997                Ok(val) => Some(val),
998                Err(_) => {
999                    stream.set_position(saved_pos);
1000                    None
1001                }
1002            };
1003            stream.expect_complete()?;
1004            stream.expect(&PtxToken::Comma)?;
1005            let c = GeneralOperand::parse(stream)?;
1006            stream.expect_complete()?;
1007            stream.expect_complete()?;
1008            stream.expect(&PtxToken::Semicolon)?;
1009            Ok(Vsub2DtypeAtypeBtypeAdd {
1010                dtype,
1011                atype,
1012                btype,
1013                add,
1014                d,
1015                mask,
1016                a,
1017                asel,
1018                b,
1019                bsel,
1020                c,
1021            })
1022        }
1023    }
1024
1025
1026    impl PtxParser for Vavrg2DtypeAtypeBtypeAdd {
1027        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1028            stream.expect_string("vavrg2")?;
1029            let dtype = Dtype::parse(stream)?;
1030            stream.expect_complete()?;
1031            let atype = Atype::parse(stream)?;
1032            stream.expect_complete()?;
1033            let btype = Btype::parse(stream)?;
1034            stream.expect_complete()?;
1035            stream.expect_string(".add")?;
1036            let add = ();
1037            stream.expect_complete()?;
1038            let d = GeneralOperand::parse(stream)?;
1039            let saved_pos = stream.position();
1040            let mask = match Mask::parse(stream) {
1041                Ok(val) => Some(val),
1042                Err(_) => {
1043                    stream.set_position(saved_pos);
1044                    None
1045                }
1046            };
1047            stream.expect_complete()?;
1048            stream.expect(&PtxToken::Comma)?;
1049            let a = GeneralOperand::parse(stream)?;
1050            let saved_pos = stream.position();
1051            let asel = match Asel::parse(stream) {
1052                Ok(val) => Some(val),
1053                Err(_) => {
1054                    stream.set_position(saved_pos);
1055                    None
1056                }
1057            };
1058            stream.expect_complete()?;
1059            stream.expect(&PtxToken::Comma)?;
1060            let b = GeneralOperand::parse(stream)?;
1061            let saved_pos = stream.position();
1062            let bsel = match Bsel::parse(stream) {
1063                Ok(val) => Some(val),
1064                Err(_) => {
1065                    stream.set_position(saved_pos);
1066                    None
1067                }
1068            };
1069            stream.expect_complete()?;
1070            stream.expect(&PtxToken::Comma)?;
1071            let c = GeneralOperand::parse(stream)?;
1072            stream.expect_complete()?;
1073            stream.expect_complete()?;
1074            stream.expect(&PtxToken::Semicolon)?;
1075            Ok(Vavrg2DtypeAtypeBtypeAdd {
1076                dtype,
1077                atype,
1078                btype,
1079                add,
1080                d,
1081                mask,
1082                a,
1083                asel,
1084                b,
1085                bsel,
1086                c,
1087            })
1088        }
1089    }
1090
1091
1092    impl PtxParser for Vabsdiff2DtypeAtypeBtypeAdd {
1093        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1094            stream.expect_string("vabsdiff2")?;
1095            let dtype = Dtype::parse(stream)?;
1096            stream.expect_complete()?;
1097            let atype = Atype::parse(stream)?;
1098            stream.expect_complete()?;
1099            let btype = Btype::parse(stream)?;
1100            stream.expect_complete()?;
1101            stream.expect_string(".add")?;
1102            let add = ();
1103            stream.expect_complete()?;
1104            let d = GeneralOperand::parse(stream)?;
1105            let saved_pos = stream.position();
1106            let mask = match Mask::parse(stream) {
1107                Ok(val) => Some(val),
1108                Err(_) => {
1109                    stream.set_position(saved_pos);
1110                    None
1111                }
1112            };
1113            stream.expect_complete()?;
1114            stream.expect(&PtxToken::Comma)?;
1115            let a = GeneralOperand::parse(stream)?;
1116            let saved_pos = stream.position();
1117            let asel = match Asel::parse(stream) {
1118                Ok(val) => Some(val),
1119                Err(_) => {
1120                    stream.set_position(saved_pos);
1121                    None
1122                }
1123            };
1124            stream.expect_complete()?;
1125            stream.expect(&PtxToken::Comma)?;
1126            let b = GeneralOperand::parse(stream)?;
1127            let saved_pos = stream.position();
1128            let bsel = match Bsel::parse(stream) {
1129                Ok(val) => Some(val),
1130                Err(_) => {
1131                    stream.set_position(saved_pos);
1132                    None
1133                }
1134            };
1135            stream.expect_complete()?;
1136            stream.expect(&PtxToken::Comma)?;
1137            let c = GeneralOperand::parse(stream)?;
1138            stream.expect_complete()?;
1139            stream.expect_complete()?;
1140            stream.expect(&PtxToken::Semicolon)?;
1141            Ok(Vabsdiff2DtypeAtypeBtypeAdd {
1142                dtype,
1143                atype,
1144                btype,
1145                add,
1146                d,
1147                mask,
1148                a,
1149                asel,
1150                b,
1151                bsel,
1152                c,
1153            })
1154        }
1155    }
1156
1157
1158    impl PtxParser for Vmin2DtypeAtypeBtypeAdd {
1159        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1160            stream.expect_string("vmin2")?;
1161            let dtype = Dtype::parse(stream)?;
1162            stream.expect_complete()?;
1163            let atype = Atype::parse(stream)?;
1164            stream.expect_complete()?;
1165            let btype = Btype::parse(stream)?;
1166            stream.expect_complete()?;
1167            stream.expect_string(".add")?;
1168            let add = ();
1169            stream.expect_complete()?;
1170            let d = GeneralOperand::parse(stream)?;
1171            let saved_pos = stream.position();
1172            let mask = match Mask::parse(stream) {
1173                Ok(val) => Some(val),
1174                Err(_) => {
1175                    stream.set_position(saved_pos);
1176                    None
1177                }
1178            };
1179            stream.expect_complete()?;
1180            stream.expect(&PtxToken::Comma)?;
1181            let a = GeneralOperand::parse(stream)?;
1182            let saved_pos = stream.position();
1183            let asel = match Asel::parse(stream) {
1184                Ok(val) => Some(val),
1185                Err(_) => {
1186                    stream.set_position(saved_pos);
1187                    None
1188                }
1189            };
1190            stream.expect_complete()?;
1191            stream.expect(&PtxToken::Comma)?;
1192            let b = GeneralOperand::parse(stream)?;
1193            let saved_pos = stream.position();
1194            let bsel = match Bsel::parse(stream) {
1195                Ok(val) => Some(val),
1196                Err(_) => {
1197                    stream.set_position(saved_pos);
1198                    None
1199                }
1200            };
1201            stream.expect_complete()?;
1202            stream.expect(&PtxToken::Comma)?;
1203            let c = GeneralOperand::parse(stream)?;
1204            stream.expect_complete()?;
1205            stream.expect_complete()?;
1206            stream.expect(&PtxToken::Semicolon)?;
1207            Ok(Vmin2DtypeAtypeBtypeAdd {
1208                dtype,
1209                atype,
1210                btype,
1211                add,
1212                d,
1213                mask,
1214                a,
1215                asel,
1216                b,
1217                bsel,
1218                c,
1219            })
1220        }
1221    }
1222
1223
1224    impl PtxParser for Vmax2DtypeAtypeBtypeAdd {
1225        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1226            stream.expect_string("vmax2")?;
1227            let dtype = Dtype::parse(stream)?;
1228            stream.expect_complete()?;
1229            let atype = Atype::parse(stream)?;
1230            stream.expect_complete()?;
1231            let btype = Btype::parse(stream)?;
1232            stream.expect_complete()?;
1233            stream.expect_string(".add")?;
1234            let add = ();
1235            stream.expect_complete()?;
1236            let d = GeneralOperand::parse(stream)?;
1237            let saved_pos = stream.position();
1238            let mask = match Mask::parse(stream) {
1239                Ok(val) => Some(val),
1240                Err(_) => {
1241                    stream.set_position(saved_pos);
1242                    None
1243                }
1244            };
1245            stream.expect_complete()?;
1246            stream.expect(&PtxToken::Comma)?;
1247            let a = GeneralOperand::parse(stream)?;
1248            let saved_pos = stream.position();
1249            let asel = match Asel::parse(stream) {
1250                Ok(val) => Some(val),
1251                Err(_) => {
1252                    stream.set_position(saved_pos);
1253                    None
1254                }
1255            };
1256            stream.expect_complete()?;
1257            stream.expect(&PtxToken::Comma)?;
1258            let b = GeneralOperand::parse(stream)?;
1259            let saved_pos = stream.position();
1260            let bsel = match Bsel::parse(stream) {
1261                Ok(val) => Some(val),
1262                Err(_) => {
1263                    stream.set_position(saved_pos);
1264                    None
1265                }
1266            };
1267            stream.expect_complete()?;
1268            stream.expect(&PtxToken::Comma)?;
1269            let c = GeneralOperand::parse(stream)?;
1270            stream.expect_complete()?;
1271            stream.expect_complete()?;
1272            stream.expect(&PtxToken::Semicolon)?;
1273            Ok(Vmax2DtypeAtypeBtypeAdd {
1274                dtype,
1275                atype,
1276                btype,
1277                add,
1278                d,
1279                mask,
1280                a,
1281                asel,
1282                b,
1283                bsel,
1284                c,
1285            })
1286        }
1287    }
1288
1289
1290}
1291
ptx_parser/parser/instruction/vop2.rs

ptx_parser/parser/instruction/
vop2.rs
