ptx_parser/parser/instruction/
vop4.rs

1//! Original PTX specification:
2//!
3//! // SIMD instruction with secondary SIMD merge operation
4//! vop4.dtype.atype.btype{.sat}  d{.mask}, a{.asel}, b{.bsel}, c;
5//! // SIMD instruction with secondary accumulate operation
6//! vop4.dtype.atype.btype.add  d{.mask}, a{.asel}, b{.bsel}, c;
7//! vop4  = { vadd4, vsub4, vavrg4, vabsdiff4, vmin4, vmax4 };
8//! .dtype = .atype = .btype = { .u32, .s32 };
9//! .mask  = { .b0,
10//! .b1, .b10,
11//! .b2, .b20, .b21, .b210,
12//! .b3, .b30, .b31, .b310, .b32, .b320, .b321, .b3210 };
13//! // defaults to .b3210
14//! .asel = .bsel = { .b.n.n.n.n };
15//! .n = { 0, 1, 2, 3, 4, 5, 6, 7};
16//! // .asel defaults to .b3210
17//! // .bsel defaults to .b7654
18
19#![allow(unused)]
20
21use crate::lexer::PtxToken;
22use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
23use crate::r#type::common::*;
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::vop4::section_0::*;
28
29    // ============================================================================
30    // Generated enum parsers
31    // ============================================================================
32
33    impl PtxParser for Asel {
34        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
35            // Try BNNNN
36            {
37                let saved_seq_pos = stream.position();
38                match (|| -> Result<_, PtxParseError> {
39                    stream.expect_string(".b")?;
40                    let b = ();
41                    let n = N::parse(stream)?;
42                    let n1 = N::parse(stream)?;
43                    let n2 = N::parse(stream)?;
44                    let n3 = N::parse(stream)?;
45                    Ok((b, n, n1, n2, n3))
46                })() {
47                    Ok((b, n, n1, n2, n3)) => {
48                        return Ok(Asel::BNNNN(b, n, n1, n2, n3));
49                    }
50                    Err(_) => {
51                        stream.set_position(saved_seq_pos);
52                    }
53                }
54            }
55            let span = stream
56                .peek()
57                .map(|(_, s)| s.clone())
58                .unwrap_or(Span { start: 0, end: 0 });
59            let expected = &["<complex>"];
60            let found = stream
61                .peek()
62                .map(|(t, _)| format!("{:?}", t))
63                .unwrap_or_else(|_| "<end of input>".to_string());
64            Err(crate::parser::unexpected_value(span, expected, found))
65        }
66    }
67
68    impl PtxParser for Atype {
69        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
70            // Try U32
71            {
72                let saved_pos = stream.position();
73                if stream.expect_string(".u32").is_ok() {
74                    return Ok(Atype::U32);
75                }
76                stream.set_position(saved_pos);
77            }
78            let saved_pos = stream.position();
79            // Try S32
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".s32").is_ok() {
83                    return Ok(Atype::S32);
84                }
85                stream.set_position(saved_pos);
86            }
87            stream.set_position(saved_pos);
88            let span = stream
89                .peek()
90                .map(|(_, s)| s.clone())
91                .unwrap_or(Span { start: 0, end: 0 });
92            let expected = &[".u32", ".s32"];
93            let found = stream
94                .peek()
95                .map(|(t, _)| format!("{:?}", t))
96                .unwrap_or_else(|_| "<end of input>".to_string());
97            Err(crate::parser::unexpected_value(span, expected, found))
98        }
99    }
100
101    impl PtxParser for Bsel {
102        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
103            // Try BNNNN
104            {
105                let saved_seq_pos = stream.position();
106                match (|| -> Result<_, PtxParseError> {
107                    stream.expect_string(".b")?;
108                    let b = ();
109                    let n = N::parse(stream)?;
110                    let n1 = N::parse(stream)?;
111                    let n2 = N::parse(stream)?;
112                    let n3 = N::parse(stream)?;
113                    Ok((b, n, n1, n2, n3))
114                })() {
115                    Ok((b, n, n1, n2, n3)) => {
116                        return Ok(Bsel::BNNNN(b, n, n1, n2, n3));
117                    }
118                    Err(_) => {
119                        stream.set_position(saved_seq_pos);
120                    }
121                }
122            }
123            let span = stream
124                .peek()
125                .map(|(_, s)| s.clone())
126                .unwrap_or(Span { start: 0, end: 0 });
127            let expected = &["<complex>"];
128            let found = stream
129                .peek()
130                .map(|(t, _)| format!("{:?}", t))
131                .unwrap_or_else(|_| "<end of input>".to_string());
132            Err(crate::parser::unexpected_value(span, expected, found))
133        }
134    }
135
136    impl PtxParser for Btype {
137        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
138            // Try U32
139            {
140                let saved_pos = stream.position();
141                if stream.expect_string(".u32").is_ok() {
142                    return Ok(Btype::U32);
143                }
144                stream.set_position(saved_pos);
145            }
146            let saved_pos = stream.position();
147            // Try S32
148            {
149                let saved_pos = stream.position();
150                if stream.expect_string(".s32").is_ok() {
151                    return Ok(Btype::S32);
152                }
153                stream.set_position(saved_pos);
154            }
155            stream.set_position(saved_pos);
156            let span = stream
157                .peek()
158                .map(|(_, s)| s.clone())
159                .unwrap_or(Span { start: 0, end: 0 });
160            let expected = &[".u32", ".s32"];
161            let found = stream
162                .peek()
163                .map(|(t, _)| format!("{:?}", t))
164                .unwrap_or_else(|_| "<end of input>".to_string());
165            Err(crate::parser::unexpected_value(span, expected, found))
166        }
167    }
168
169    impl PtxParser for Dtype {
170        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
171            // Try U32
172            {
173                let saved_pos = stream.position();
174                if stream.expect_string(".u32").is_ok() {
175                    return Ok(Dtype::U32);
176                }
177                stream.set_position(saved_pos);
178            }
179            let saved_pos = stream.position();
180            // Try S32
181            {
182                let saved_pos = stream.position();
183                if stream.expect_string(".s32").is_ok() {
184                    return Ok(Dtype::S32);
185                }
186                stream.set_position(saved_pos);
187            }
188            stream.set_position(saved_pos);
189            let span = stream
190                .peek()
191                .map(|(_, s)| s.clone())
192                .unwrap_or(Span { start: 0, end: 0 });
193            let expected = &[".u32", ".s32"];
194            let found = stream
195                .peek()
196                .map(|(t, _)| format!("{:?}", t))
197                .unwrap_or_else(|_| "<end of input>".to_string());
198            Err(crate::parser::unexpected_value(span, expected, found))
199        }
200    }
201
202    impl PtxParser for Mask {
203        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
204            // Try B3210
205            {
206                let saved_pos = stream.position();
207                if stream.expect_string(".b3210").is_ok() {
208                    return Ok(Mask::B3210);
209                }
210                stream.set_position(saved_pos);
211            }
212            let saved_pos = stream.position();
213            // Try B210
214            {
215                let saved_pos = stream.position();
216                if stream.expect_string(".b210").is_ok() {
217                    return Ok(Mask::B210);
218                }
219                stream.set_position(saved_pos);
220            }
221            stream.set_position(saved_pos);
222            let saved_pos = stream.position();
223            // Try B310
224            {
225                let saved_pos = stream.position();
226                if stream.expect_string(".b310").is_ok() {
227                    return Ok(Mask::B310);
228                }
229                stream.set_position(saved_pos);
230            }
231            stream.set_position(saved_pos);
232            let saved_pos = stream.position();
233            // Try B320
234            {
235                let saved_pos = stream.position();
236                if stream.expect_string(".b320").is_ok() {
237                    return Ok(Mask::B320);
238                }
239                stream.set_position(saved_pos);
240            }
241            stream.set_position(saved_pos);
242            let saved_pos = stream.position();
243            // Try B321
244            {
245                let saved_pos = stream.position();
246                if stream.expect_string(".b321").is_ok() {
247                    return Ok(Mask::B321);
248                }
249                stream.set_position(saved_pos);
250            }
251            stream.set_position(saved_pos);
252            let saved_pos = stream.position();
253            // Try B10
254            {
255                let saved_pos = stream.position();
256                if stream.expect_string(".b10").is_ok() {
257                    return Ok(Mask::B10);
258                }
259                stream.set_position(saved_pos);
260            }
261            stream.set_position(saved_pos);
262            let saved_pos = stream.position();
263            // Try B20
264            {
265                let saved_pos = stream.position();
266                if stream.expect_string(".b20").is_ok() {
267                    return Ok(Mask::B20);
268                }
269                stream.set_position(saved_pos);
270            }
271            stream.set_position(saved_pos);
272            let saved_pos = stream.position();
273            // Try B21
274            {
275                let saved_pos = stream.position();
276                if stream.expect_string(".b21").is_ok() {
277                    return Ok(Mask::B21);
278                }
279                stream.set_position(saved_pos);
280            }
281            stream.set_position(saved_pos);
282            let saved_pos = stream.position();
283            // Try B30
284            {
285                let saved_pos = stream.position();
286                if stream.expect_string(".b30").is_ok() {
287                    return Ok(Mask::B30);
288                }
289                stream.set_position(saved_pos);
290            }
291            stream.set_position(saved_pos);
292            let saved_pos = stream.position();
293            // Try B31
294            {
295                let saved_pos = stream.position();
296                if stream.expect_string(".b31").is_ok() {
297                    return Ok(Mask::B31);
298                }
299                stream.set_position(saved_pos);
300            }
301            stream.set_position(saved_pos);
302            let saved_pos = stream.position();
303            // Try B32
304            {
305                let saved_pos = stream.position();
306                if stream.expect_string(".b32").is_ok() {
307                    return Ok(Mask::B32);
308                }
309                stream.set_position(saved_pos);
310            }
311            stream.set_position(saved_pos);
312            let saved_pos = stream.position();
313            // Try B0
314            {
315                let saved_pos = stream.position();
316                if stream.expect_string(".b0").is_ok() {
317                    return Ok(Mask::B0);
318                }
319                stream.set_position(saved_pos);
320            }
321            stream.set_position(saved_pos);
322            let saved_pos = stream.position();
323            // Try B1
324            {
325                let saved_pos = stream.position();
326                if stream.expect_string(".b1").is_ok() {
327                    return Ok(Mask::B1);
328                }
329                stream.set_position(saved_pos);
330            }
331            stream.set_position(saved_pos);
332            let saved_pos = stream.position();
333            // Try B2
334            {
335                let saved_pos = stream.position();
336                if stream.expect_string(".b2").is_ok() {
337                    return Ok(Mask::B2);
338                }
339                stream.set_position(saved_pos);
340            }
341            stream.set_position(saved_pos);
342            let saved_pos = stream.position();
343            // Try B3
344            {
345                let saved_pos = stream.position();
346                if stream.expect_string(".b3").is_ok() {
347                    return Ok(Mask::B3);
348                }
349                stream.set_position(saved_pos);
350            }
351            stream.set_position(saved_pos);
352            let span = stream
353                .peek()
354                .map(|(_, s)| s.clone())
355                .unwrap_or(Span { start: 0, end: 0 });
356            let expected = &[
357                ".b3210", ".b210", ".b310", ".b320", ".b321", ".b10", ".b20", ".b21", ".b30",
358                ".b31", ".b32", ".b0", ".b1", ".b2", ".b3",
359            ];
360            let found = stream
361                .peek()
362                .map(|(t, _)| format!("{:?}", t))
363                .unwrap_or_else(|_| "<end of input>".to_string());
364            Err(crate::parser::unexpected_value(span, expected, found))
365        }
366    }
367
368    impl PtxParser for N {
369        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
370            // Try _0
371            {
372                let saved_pos = stream.position();
373                if stream.expect_string("0").is_ok() {
374                    return Ok(N::_0);
375                }
376                stream.set_position(saved_pos);
377            }
378            let saved_pos = stream.position();
379            // Try _1
380            {
381                let saved_pos = stream.position();
382                if stream.expect_string("1").is_ok() {
383                    return Ok(N::_1);
384                }
385                stream.set_position(saved_pos);
386            }
387            stream.set_position(saved_pos);
388            let saved_pos = stream.position();
389            // Try _2
390            {
391                let saved_pos = stream.position();
392                if stream.expect_string("2").is_ok() {
393                    return Ok(N::_2);
394                }
395                stream.set_position(saved_pos);
396            }
397            stream.set_position(saved_pos);
398            let saved_pos = stream.position();
399            // Try _3
400            {
401                let saved_pos = stream.position();
402                if stream.expect_string("3").is_ok() {
403                    return Ok(N::_3);
404                }
405                stream.set_position(saved_pos);
406            }
407            stream.set_position(saved_pos);
408            let saved_pos = stream.position();
409            // Try _4
410            {
411                let saved_pos = stream.position();
412                if stream.expect_string("4").is_ok() {
413                    return Ok(N::_4);
414                }
415                stream.set_position(saved_pos);
416            }
417            stream.set_position(saved_pos);
418            let saved_pos = stream.position();
419            // Try _5
420            {
421                let saved_pos = stream.position();
422                if stream.expect_string("5").is_ok() {
423                    return Ok(N::_5);
424                }
425                stream.set_position(saved_pos);
426            }
427            stream.set_position(saved_pos);
428            let saved_pos = stream.position();
429            // Try _6
430            {
431                let saved_pos = stream.position();
432                if stream.expect_string("6").is_ok() {
433                    return Ok(N::_6);
434                }
435                stream.set_position(saved_pos);
436            }
437            stream.set_position(saved_pos);
438            let saved_pos = stream.position();
439            // Try _7
440            {
441                let saved_pos = stream.position();
442                if stream.expect_string("7").is_ok() {
443                    return Ok(N::_7);
444                }
445                stream.set_position(saved_pos);
446            }
447            stream.set_position(saved_pos);
448            let span = stream
449                .peek()
450                .map(|(_, s)| s.clone())
451                .unwrap_or(Span { start: 0, end: 0 });
452            let expected = &["0", "1", "2", "3", "4", "5", "6", "7"];
453            let found = stream
454                .peek()
455                .map(|(t, _)| format!("{:?}", t))
456                .unwrap_or_else(|_| "<end of input>".to_string());
457            Err(crate::parser::unexpected_value(span, expected, found))
458        }
459    }
460
461    impl PtxParser for Vadd4DtypeAtypeBtypeSat {
462        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
463            stream.expect_string("vadd4")?;
464            let dtype = Dtype::parse(stream)?;
465            stream.expect_complete()?;
466            let atype = Atype::parse(stream)?;
467            stream.expect_complete()?;
468            let btype = Btype::parse(stream)?;
469            stream.expect_complete()?;
470            let saved_pos = stream.position();
471            let sat = stream.expect_string(".sat").is_ok();
472            if !sat {
473                stream.set_position(saved_pos);
474            }
475            stream.expect_complete()?;
476            let d = GeneralOperand::parse(stream)?;
477            let saved_pos = stream.position();
478            let mask = match Mask::parse(stream) {
479                Ok(val) => Some(val),
480                Err(_) => {
481                    stream.set_position(saved_pos);
482                    None
483                }
484            };
485            stream.expect_complete()?;
486            stream.expect(&PtxToken::Comma)?;
487            let a = GeneralOperand::parse(stream)?;
488            let saved_pos = stream.position();
489            let asel = match Asel::parse(stream) {
490                Ok(val) => Some(val),
491                Err(_) => {
492                    stream.set_position(saved_pos);
493                    None
494                }
495            };
496            stream.expect_complete()?;
497            stream.expect(&PtxToken::Comma)?;
498            let b = GeneralOperand::parse(stream)?;
499            let saved_pos = stream.position();
500            let bsel = match Bsel::parse(stream) {
501                Ok(val) => Some(val),
502                Err(_) => {
503                    stream.set_position(saved_pos);
504                    None
505                }
506            };
507            stream.expect_complete()?;
508            stream.expect(&PtxToken::Comma)?;
509            let c = GeneralOperand::parse(stream)?;
510            stream.expect_complete()?;
511            stream.expect_complete()?;
512            stream.expect(&PtxToken::Semicolon)?;
513            Ok(Vadd4DtypeAtypeBtypeSat {
514                dtype,
515                atype,
516                btype,
517                sat,
518                d,
519                mask,
520                a,
521                asel,
522                b,
523                bsel,
524                c,
525            })
526        }
527    }
528
529    impl PtxParser for Vsub4DtypeAtypeBtypeSat {
530        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
531            stream.expect_string("vsub4")?;
532            let dtype = Dtype::parse(stream)?;
533            stream.expect_complete()?;
534            let atype = Atype::parse(stream)?;
535            stream.expect_complete()?;
536            let btype = Btype::parse(stream)?;
537            stream.expect_complete()?;
538            let saved_pos = stream.position();
539            let sat = stream.expect_string(".sat").is_ok();
540            if !sat {
541                stream.set_position(saved_pos);
542            }
543            stream.expect_complete()?;
544            let d = GeneralOperand::parse(stream)?;
545            let saved_pos = stream.position();
546            let mask = match Mask::parse(stream) {
547                Ok(val) => Some(val),
548                Err(_) => {
549                    stream.set_position(saved_pos);
550                    None
551                }
552            };
553            stream.expect_complete()?;
554            stream.expect(&PtxToken::Comma)?;
555            let a = GeneralOperand::parse(stream)?;
556            let saved_pos = stream.position();
557            let asel = match Asel::parse(stream) {
558                Ok(val) => Some(val),
559                Err(_) => {
560                    stream.set_position(saved_pos);
561                    None
562                }
563            };
564            stream.expect_complete()?;
565            stream.expect(&PtxToken::Comma)?;
566            let b = GeneralOperand::parse(stream)?;
567            let saved_pos = stream.position();
568            let bsel = match Bsel::parse(stream) {
569                Ok(val) => Some(val),
570                Err(_) => {
571                    stream.set_position(saved_pos);
572                    None
573                }
574            };
575            stream.expect_complete()?;
576            stream.expect(&PtxToken::Comma)?;
577            let c = GeneralOperand::parse(stream)?;
578            stream.expect_complete()?;
579            stream.expect_complete()?;
580            stream.expect(&PtxToken::Semicolon)?;
581            Ok(Vsub4DtypeAtypeBtypeSat {
582                dtype,
583                atype,
584                btype,
585                sat,
586                d,
587                mask,
588                a,
589                asel,
590                b,
591                bsel,
592                c,
593            })
594        }
595    }
596
597    impl PtxParser for Vavrg4DtypeAtypeBtypeSat {
598        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
599            stream.expect_string("vavrg4")?;
600            let dtype = Dtype::parse(stream)?;
601            stream.expect_complete()?;
602            let atype = Atype::parse(stream)?;
603            stream.expect_complete()?;
604            let btype = Btype::parse(stream)?;
605            stream.expect_complete()?;
606            let saved_pos = stream.position();
607            let sat = stream.expect_string(".sat").is_ok();
608            if !sat {
609                stream.set_position(saved_pos);
610            }
611            stream.expect_complete()?;
612            let d = GeneralOperand::parse(stream)?;
613            let saved_pos = stream.position();
614            let mask = match Mask::parse(stream) {
615                Ok(val) => Some(val),
616                Err(_) => {
617                    stream.set_position(saved_pos);
618                    None
619                }
620            };
621            stream.expect_complete()?;
622            stream.expect(&PtxToken::Comma)?;
623            let a = GeneralOperand::parse(stream)?;
624            let saved_pos = stream.position();
625            let asel = match Asel::parse(stream) {
626                Ok(val) => Some(val),
627                Err(_) => {
628                    stream.set_position(saved_pos);
629                    None
630                }
631            };
632            stream.expect_complete()?;
633            stream.expect(&PtxToken::Comma)?;
634            let b = GeneralOperand::parse(stream)?;
635            let saved_pos = stream.position();
636            let bsel = match Bsel::parse(stream) {
637                Ok(val) => Some(val),
638                Err(_) => {
639                    stream.set_position(saved_pos);
640                    None
641                }
642            };
643            stream.expect_complete()?;
644            stream.expect(&PtxToken::Comma)?;
645            let c = GeneralOperand::parse(stream)?;
646            stream.expect_complete()?;
647            stream.expect_complete()?;
648            stream.expect(&PtxToken::Semicolon)?;
649            Ok(Vavrg4DtypeAtypeBtypeSat {
650                dtype,
651                atype,
652                btype,
653                sat,
654                d,
655                mask,
656                a,
657                asel,
658                b,
659                bsel,
660                c,
661            })
662        }
663    }
664
665    impl PtxParser for Vabsdiff4DtypeAtypeBtypeSat {
666        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
667            stream.expect_string("vabsdiff4")?;
668            let dtype = Dtype::parse(stream)?;
669            stream.expect_complete()?;
670            let atype = Atype::parse(stream)?;
671            stream.expect_complete()?;
672            let btype = Btype::parse(stream)?;
673            stream.expect_complete()?;
674            let saved_pos = stream.position();
675            let sat = stream.expect_string(".sat").is_ok();
676            if !sat {
677                stream.set_position(saved_pos);
678            }
679            stream.expect_complete()?;
680            let d = GeneralOperand::parse(stream)?;
681            let saved_pos = stream.position();
682            let mask = match Mask::parse(stream) {
683                Ok(val) => Some(val),
684                Err(_) => {
685                    stream.set_position(saved_pos);
686                    None
687                }
688            };
689            stream.expect_complete()?;
690            stream.expect(&PtxToken::Comma)?;
691            let a = GeneralOperand::parse(stream)?;
692            let saved_pos = stream.position();
693            let asel = match Asel::parse(stream) {
694                Ok(val) => Some(val),
695                Err(_) => {
696                    stream.set_position(saved_pos);
697                    None
698                }
699            };
700            stream.expect_complete()?;
701            stream.expect(&PtxToken::Comma)?;
702            let b = GeneralOperand::parse(stream)?;
703            let saved_pos = stream.position();
704            let bsel = match Bsel::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 c = GeneralOperand::parse(stream)?;
714            stream.expect_complete()?;
715            stream.expect_complete()?;
716            stream.expect(&PtxToken::Semicolon)?;
717            Ok(Vabsdiff4DtypeAtypeBtypeSat {
718                dtype,
719                atype,
720                btype,
721                sat,
722                d,
723                mask,
724                a,
725                asel,
726                b,
727                bsel,
728                c,
729            })
730        }
731    }
732
733    impl PtxParser for Vmin4DtypeAtypeBtypeSat {
734        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
735            stream.expect_string("vmin4")?;
736            let dtype = Dtype::parse(stream)?;
737            stream.expect_complete()?;
738            let atype = Atype::parse(stream)?;
739            stream.expect_complete()?;
740            let btype = Btype::parse(stream)?;
741            stream.expect_complete()?;
742            let saved_pos = stream.position();
743            let sat = stream.expect_string(".sat").is_ok();
744            if !sat {
745                stream.set_position(saved_pos);
746            }
747            stream.expect_complete()?;
748            let d = GeneralOperand::parse(stream)?;
749            let saved_pos = stream.position();
750            let mask = match Mask::parse(stream) {
751                Ok(val) => Some(val),
752                Err(_) => {
753                    stream.set_position(saved_pos);
754                    None
755                }
756            };
757            stream.expect_complete()?;
758            stream.expect(&PtxToken::Comma)?;
759            let a = GeneralOperand::parse(stream)?;
760            let saved_pos = stream.position();
761            let asel = match Asel::parse(stream) {
762                Ok(val) => Some(val),
763                Err(_) => {
764                    stream.set_position(saved_pos);
765                    None
766                }
767            };
768            stream.expect_complete()?;
769            stream.expect(&PtxToken::Comma)?;
770            let b = GeneralOperand::parse(stream)?;
771            let saved_pos = stream.position();
772            let bsel = match Bsel::parse(stream) {
773                Ok(val) => Some(val),
774                Err(_) => {
775                    stream.set_position(saved_pos);
776                    None
777                }
778            };
779            stream.expect_complete()?;
780            stream.expect(&PtxToken::Comma)?;
781            let c = GeneralOperand::parse(stream)?;
782            stream.expect_complete()?;
783            stream.expect_complete()?;
784            stream.expect(&PtxToken::Semicolon)?;
785            Ok(Vmin4DtypeAtypeBtypeSat {
786                dtype,
787                atype,
788                btype,
789                sat,
790                d,
791                mask,
792                a,
793                asel,
794                b,
795                bsel,
796                c,
797            })
798        }
799    }
800
801    impl PtxParser for Vmax4DtypeAtypeBtypeSat {
802        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
803            stream.expect_string("vmax4")?;
804            let dtype = Dtype::parse(stream)?;
805            stream.expect_complete()?;
806            let atype = Atype::parse(stream)?;
807            stream.expect_complete()?;
808            let btype = Btype::parse(stream)?;
809            stream.expect_complete()?;
810            let saved_pos = stream.position();
811            let sat = stream.expect_string(".sat").is_ok();
812            if !sat {
813                stream.set_position(saved_pos);
814            }
815            stream.expect_complete()?;
816            let d = GeneralOperand::parse(stream)?;
817            let saved_pos = stream.position();
818            let mask = match Mask::parse(stream) {
819                Ok(val) => Some(val),
820                Err(_) => {
821                    stream.set_position(saved_pos);
822                    None
823                }
824            };
825            stream.expect_complete()?;
826            stream.expect(&PtxToken::Comma)?;
827            let a = GeneralOperand::parse(stream)?;
828            let saved_pos = stream.position();
829            let asel = match Asel::parse(stream) {
830                Ok(val) => Some(val),
831                Err(_) => {
832                    stream.set_position(saved_pos);
833                    None
834                }
835            };
836            stream.expect_complete()?;
837            stream.expect(&PtxToken::Comma)?;
838            let b = GeneralOperand::parse(stream)?;
839            let saved_pos = stream.position();
840            let bsel = match Bsel::parse(stream) {
841                Ok(val) => Some(val),
842                Err(_) => {
843                    stream.set_position(saved_pos);
844                    None
845                }
846            };
847            stream.expect_complete()?;
848            stream.expect(&PtxToken::Comma)?;
849            let c = GeneralOperand::parse(stream)?;
850            stream.expect_complete()?;
851            stream.expect_complete()?;
852            stream.expect(&PtxToken::Semicolon)?;
853            Ok(Vmax4DtypeAtypeBtypeSat {
854                dtype,
855                atype,
856                btype,
857                sat,
858                d,
859                mask,
860                a,
861                asel,
862                b,
863                bsel,
864                c,
865            })
866        }
867    }
868
869    impl PtxParser for Vadd4DtypeAtypeBtypeAdd {
870        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
871            stream.expect_string("vadd4")?;
872            let dtype = Dtype::parse(stream)?;
873            stream.expect_complete()?;
874            let atype = Atype::parse(stream)?;
875            stream.expect_complete()?;
876            let btype = Btype::parse(stream)?;
877            stream.expect_complete()?;
878            stream.expect_string(".add")?;
879            let add = ();
880            stream.expect_complete()?;
881            let d = GeneralOperand::parse(stream)?;
882            let saved_pos = stream.position();
883            let mask = match Mask::parse(stream) {
884                Ok(val) => Some(val),
885                Err(_) => {
886                    stream.set_position(saved_pos);
887                    None
888                }
889            };
890            stream.expect_complete()?;
891            stream.expect(&PtxToken::Comma)?;
892            let a = GeneralOperand::parse(stream)?;
893            let saved_pos = stream.position();
894            let asel = match Asel::parse(stream) {
895                Ok(val) => Some(val),
896                Err(_) => {
897                    stream.set_position(saved_pos);
898                    None
899                }
900            };
901            stream.expect_complete()?;
902            stream.expect(&PtxToken::Comma)?;
903            let b = GeneralOperand::parse(stream)?;
904            let saved_pos = stream.position();
905            let bsel = match Bsel::parse(stream) {
906                Ok(val) => Some(val),
907                Err(_) => {
908                    stream.set_position(saved_pos);
909                    None
910                }
911            };
912            stream.expect_complete()?;
913            stream.expect(&PtxToken::Comma)?;
914            let c = GeneralOperand::parse(stream)?;
915            stream.expect_complete()?;
916            stream.expect_complete()?;
917            stream.expect(&PtxToken::Semicolon)?;
918            Ok(Vadd4DtypeAtypeBtypeAdd {
919                dtype,
920                atype,
921                btype,
922                add,
923                d,
924                mask,
925                a,
926                asel,
927                b,
928                bsel,
929                c,
930            })
931        }
932    }
933
934    impl PtxParser for Vsub4DtypeAtypeBtypeAdd {
935        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
936            stream.expect_string("vsub4")?;
937            let dtype = Dtype::parse(stream)?;
938            stream.expect_complete()?;
939            let atype = Atype::parse(stream)?;
940            stream.expect_complete()?;
941            let btype = Btype::parse(stream)?;
942            stream.expect_complete()?;
943            stream.expect_string(".add")?;
944            let add = ();
945            stream.expect_complete()?;
946            let d = GeneralOperand::parse(stream)?;
947            let saved_pos = stream.position();
948            let mask = match Mask::parse(stream) {
949                Ok(val) => Some(val),
950                Err(_) => {
951                    stream.set_position(saved_pos);
952                    None
953                }
954            };
955            stream.expect_complete()?;
956            stream.expect(&PtxToken::Comma)?;
957            let a = GeneralOperand::parse(stream)?;
958            let saved_pos = stream.position();
959            let asel = match Asel::parse(stream) {
960                Ok(val) => Some(val),
961                Err(_) => {
962                    stream.set_position(saved_pos);
963                    None
964                }
965            };
966            stream.expect_complete()?;
967            stream.expect(&PtxToken::Comma)?;
968            let b = GeneralOperand::parse(stream)?;
969            let saved_pos = stream.position();
970            let bsel = match Bsel::parse(stream) {
971                Ok(val) => Some(val),
972                Err(_) => {
973                    stream.set_position(saved_pos);
974                    None
975                }
976            };
977            stream.expect_complete()?;
978            stream.expect(&PtxToken::Comma)?;
979            let c = GeneralOperand::parse(stream)?;
980            stream.expect_complete()?;
981            stream.expect_complete()?;
982            stream.expect(&PtxToken::Semicolon)?;
983            Ok(Vsub4DtypeAtypeBtypeAdd {
984                dtype,
985                atype,
986                btype,
987                add,
988                d,
989                mask,
990                a,
991                asel,
992                b,
993                bsel,
994                c,
995            })
996        }
997    }
998
999    impl PtxParser for Vavrg4DtypeAtypeBtypeAdd {
1000        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1001            stream.expect_string("vavrg4")?;
1002            let dtype = Dtype::parse(stream)?;
1003            stream.expect_complete()?;
1004            let atype = Atype::parse(stream)?;
1005            stream.expect_complete()?;
1006            let btype = Btype::parse(stream)?;
1007            stream.expect_complete()?;
1008            stream.expect_string(".add")?;
1009            let add = ();
1010            stream.expect_complete()?;
1011            let d = GeneralOperand::parse(stream)?;
1012            let saved_pos = stream.position();
1013            let mask = match Mask::parse(stream) {
1014                Ok(val) => Some(val),
1015                Err(_) => {
1016                    stream.set_position(saved_pos);
1017                    None
1018                }
1019            };
1020            stream.expect_complete()?;
1021            stream.expect(&PtxToken::Comma)?;
1022            let a = GeneralOperand::parse(stream)?;
1023            let saved_pos = stream.position();
1024            let asel = match Asel::parse(stream) {
1025                Ok(val) => Some(val),
1026                Err(_) => {
1027                    stream.set_position(saved_pos);
1028                    None
1029                }
1030            };
1031            stream.expect_complete()?;
1032            stream.expect(&PtxToken::Comma)?;
1033            let b = GeneralOperand::parse(stream)?;
1034            let saved_pos = stream.position();
1035            let bsel = match Bsel::parse(stream) {
1036                Ok(val) => Some(val),
1037                Err(_) => {
1038                    stream.set_position(saved_pos);
1039                    None
1040                }
1041            };
1042            stream.expect_complete()?;
1043            stream.expect(&PtxToken::Comma)?;
1044            let c = GeneralOperand::parse(stream)?;
1045            stream.expect_complete()?;
1046            stream.expect_complete()?;
1047            stream.expect(&PtxToken::Semicolon)?;
1048            Ok(Vavrg4DtypeAtypeBtypeAdd {
1049                dtype,
1050                atype,
1051                btype,
1052                add,
1053                d,
1054                mask,
1055                a,
1056                asel,
1057                b,
1058                bsel,
1059                c,
1060            })
1061        }
1062    }
1063
1064    impl PtxParser for Vabsdiff4DtypeAtypeBtypeAdd {
1065        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1066            stream.expect_string("vabsdiff4")?;
1067            let dtype = Dtype::parse(stream)?;
1068            stream.expect_complete()?;
1069            let atype = Atype::parse(stream)?;
1070            stream.expect_complete()?;
1071            let btype = Btype::parse(stream)?;
1072            stream.expect_complete()?;
1073            stream.expect_string(".add")?;
1074            let add = ();
1075            stream.expect_complete()?;
1076            let d = GeneralOperand::parse(stream)?;
1077            let saved_pos = stream.position();
1078            let mask = match Mask::parse(stream) {
1079                Ok(val) => Some(val),
1080                Err(_) => {
1081                    stream.set_position(saved_pos);
1082                    None
1083                }
1084            };
1085            stream.expect_complete()?;
1086            stream.expect(&PtxToken::Comma)?;
1087            let a = GeneralOperand::parse(stream)?;
1088            let saved_pos = stream.position();
1089            let asel = match Asel::parse(stream) {
1090                Ok(val) => Some(val),
1091                Err(_) => {
1092                    stream.set_position(saved_pos);
1093                    None
1094                }
1095            };
1096            stream.expect_complete()?;
1097            stream.expect(&PtxToken::Comma)?;
1098            let b = GeneralOperand::parse(stream)?;
1099            let saved_pos = stream.position();
1100            let bsel = match Bsel::parse(stream) {
1101                Ok(val) => Some(val),
1102                Err(_) => {
1103                    stream.set_position(saved_pos);
1104                    None
1105                }
1106            };
1107            stream.expect_complete()?;
1108            stream.expect(&PtxToken::Comma)?;
1109            let c = GeneralOperand::parse(stream)?;
1110            stream.expect_complete()?;
1111            stream.expect_complete()?;
1112            stream.expect(&PtxToken::Semicolon)?;
1113            Ok(Vabsdiff4DtypeAtypeBtypeAdd {
1114                dtype,
1115                atype,
1116                btype,
1117                add,
1118                d,
1119                mask,
1120                a,
1121                asel,
1122                b,
1123                bsel,
1124                c,
1125            })
1126        }
1127    }
1128
1129    impl PtxParser for Vmin4DtypeAtypeBtypeAdd {
1130        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1131            stream.expect_string("vmin4")?;
1132            let dtype = Dtype::parse(stream)?;
1133            stream.expect_complete()?;
1134            let atype = Atype::parse(stream)?;
1135            stream.expect_complete()?;
1136            let btype = Btype::parse(stream)?;
1137            stream.expect_complete()?;
1138            stream.expect_string(".add")?;
1139            let add = ();
1140            stream.expect_complete()?;
1141            let d = GeneralOperand::parse(stream)?;
1142            let saved_pos = stream.position();
1143            let mask = match Mask::parse(stream) {
1144                Ok(val) => Some(val),
1145                Err(_) => {
1146                    stream.set_position(saved_pos);
1147                    None
1148                }
1149            };
1150            stream.expect_complete()?;
1151            stream.expect(&PtxToken::Comma)?;
1152            let a = GeneralOperand::parse(stream)?;
1153            let saved_pos = stream.position();
1154            let asel = match Asel::parse(stream) {
1155                Ok(val) => Some(val),
1156                Err(_) => {
1157                    stream.set_position(saved_pos);
1158                    None
1159                }
1160            };
1161            stream.expect_complete()?;
1162            stream.expect(&PtxToken::Comma)?;
1163            let b = GeneralOperand::parse(stream)?;
1164            let saved_pos = stream.position();
1165            let bsel = match Bsel::parse(stream) {
1166                Ok(val) => Some(val),
1167                Err(_) => {
1168                    stream.set_position(saved_pos);
1169                    None
1170                }
1171            };
1172            stream.expect_complete()?;
1173            stream.expect(&PtxToken::Comma)?;
1174            let c = GeneralOperand::parse(stream)?;
1175            stream.expect_complete()?;
1176            stream.expect_complete()?;
1177            stream.expect(&PtxToken::Semicolon)?;
1178            Ok(Vmin4DtypeAtypeBtypeAdd {
1179                dtype,
1180                atype,
1181                btype,
1182                add,
1183                d,
1184                mask,
1185                a,
1186                asel,
1187                b,
1188                bsel,
1189                c,
1190            })
1191        }
1192    }
1193
1194    impl PtxParser for Vmax4DtypeAtypeBtypeAdd {
1195        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1196            stream.expect_string("vmax4")?;
1197            let dtype = Dtype::parse(stream)?;
1198            stream.expect_complete()?;
1199            let atype = Atype::parse(stream)?;
1200            stream.expect_complete()?;
1201            let btype = Btype::parse(stream)?;
1202            stream.expect_complete()?;
1203            stream.expect_string(".add")?;
1204            let add = ();
1205            stream.expect_complete()?;
1206            let d = GeneralOperand::parse(stream)?;
1207            let saved_pos = stream.position();
1208            let mask = match Mask::parse(stream) {
1209                Ok(val) => Some(val),
1210                Err(_) => {
1211                    stream.set_position(saved_pos);
1212                    None
1213                }
1214            };
1215            stream.expect_complete()?;
1216            stream.expect(&PtxToken::Comma)?;
1217            let a = GeneralOperand::parse(stream)?;
1218            let saved_pos = stream.position();
1219            let asel = match Asel::parse(stream) {
1220                Ok(val) => Some(val),
1221                Err(_) => {
1222                    stream.set_position(saved_pos);
1223                    None
1224                }
1225            };
1226            stream.expect_complete()?;
1227            stream.expect(&PtxToken::Comma)?;
1228            let b = GeneralOperand::parse(stream)?;
1229            let saved_pos = stream.position();
1230            let bsel = match Bsel::parse(stream) {
1231                Ok(val) => Some(val),
1232                Err(_) => {
1233                    stream.set_position(saved_pos);
1234                    None
1235                }
1236            };
1237            stream.expect_complete()?;
1238            stream.expect(&PtxToken::Comma)?;
1239            let c = GeneralOperand::parse(stream)?;
1240            stream.expect_complete()?;
1241            stream.expect_complete()?;
1242            stream.expect(&PtxToken::Semicolon)?;
1243            Ok(Vmax4DtypeAtypeBtypeAdd {
1244                dtype,
1245                atype,
1246                btype,
1247                add,
1248                d,
1249                mask,
1250                a,
1251                asel,
1252                b,
1253                bsel,
1254                c,
1255            })
1256        }
1257    }
1258}
ptx_parser/parser/instruction/vop4.rs

ptx_parser/parser/instruction/
vop4.rs
