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

ptx_parser/parser/instruction/
vop2.rs
