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

ptx_parser/parser/instruction/
vop4.rs
