ptx_parser/parser/instruction/
vsh.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vop.dtype.atype.u32{.sat}.mode       d, a{.asel}, b{.bsel};
5//! vop.dtype.atype.u32{.sat}.mode.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vop.dtype.atype.u32{.sat}.mode  d.dsel, a{.asel}, b{.bsel}, c;
8//! vop   = { vshl, vshr };
9//! .dtype = .atype = { .u32, .s32 };
10//! .mode  = { .clamp, .wrap };
11//! .dsel  = .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
12//! .op2   = { .add, .min, .max };
13
14#![allow(unused)]
15
16use crate::lexer::PtxToken;
17use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
18use crate::r#type::common::*;
19
20pub mod section_0 {
21    use super::*;
22    use crate::r#type::instruction::vsh::section_0::*;
23
24    // ============================================================================
25    // Generated enum parsers
26    // ============================================================================
27
28    impl PtxParser for Asel {
29        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
30            // Try B0
31            {
32                let saved_pos = stream.position();
33                if stream.expect_string(".b0").is_ok() {
34                    return Ok(Asel::B0);
35                }
36                stream.set_position(saved_pos);
37            }
38            let saved_pos = stream.position();
39            // Try B1
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".b1").is_ok() {
43                    return Ok(Asel::B1);
44                }
45                stream.set_position(saved_pos);
46            }
47            stream.set_position(saved_pos);
48            let saved_pos = stream.position();
49            // Try B2
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".b2").is_ok() {
53                    return Ok(Asel::B2);
54                }
55                stream.set_position(saved_pos);
56            }
57            stream.set_position(saved_pos);
58            let saved_pos = stream.position();
59            // Try B3
60            {
61                let saved_pos = stream.position();
62                if stream.expect_string(".b3").is_ok() {
63                    return Ok(Asel::B3);
64                }
65                stream.set_position(saved_pos);
66            }
67            stream.set_position(saved_pos);
68            let saved_pos = stream.position();
69            // Try H0
70            {
71                let saved_pos = stream.position();
72                if stream.expect_string(".h0").is_ok() {
73                    return Ok(Asel::H0);
74                }
75                stream.set_position(saved_pos);
76            }
77            stream.set_position(saved_pos);
78            let saved_pos = stream.position();
79            // Try H1
80            {
81                let saved_pos = stream.position();
82                if stream.expect_string(".h1").is_ok() {
83                    return Ok(Asel::H1);
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 = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
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 Atype {
102        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
103            // Try U32
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".u32").is_ok() {
107                    return Ok(Atype::U32);
108                }
109                stream.set_position(saved_pos);
110            }
111            let saved_pos = stream.position();
112            // Try S32
113            {
114                let saved_pos = stream.position();
115                if stream.expect_string(".s32").is_ok() {
116                    return Ok(Atype::S32);
117                }
118                stream.set_position(saved_pos);
119            }
120            stream.set_position(saved_pos);
121            let span = stream
122                .peek()
123                .map(|(_, s)| s.clone())
124                .unwrap_or(Span { start: 0, end: 0 });
125            let expected = &[".u32", ".s32"];
126            let found = stream
127                .peek()
128                .map(|(t, _)| format!("{:?}", t))
129                .unwrap_or_else(|_| "<end of input>".to_string());
130            Err(crate::parser::unexpected_value(span, expected, found))
131        }
132    }
133
134    impl PtxParser for Bsel {
135        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
136            // Try B0
137            {
138                let saved_pos = stream.position();
139                if stream.expect_string(".b0").is_ok() {
140                    return Ok(Bsel::B0);
141                }
142                stream.set_position(saved_pos);
143            }
144            let saved_pos = stream.position();
145            // Try B1
146            {
147                let saved_pos = stream.position();
148                if stream.expect_string(".b1").is_ok() {
149                    return Ok(Bsel::B1);
150                }
151                stream.set_position(saved_pos);
152            }
153            stream.set_position(saved_pos);
154            let saved_pos = stream.position();
155            // Try B2
156            {
157                let saved_pos = stream.position();
158                if stream.expect_string(".b2").is_ok() {
159                    return Ok(Bsel::B2);
160                }
161                stream.set_position(saved_pos);
162            }
163            stream.set_position(saved_pos);
164            let saved_pos = stream.position();
165            // Try B3
166            {
167                let saved_pos = stream.position();
168                if stream.expect_string(".b3").is_ok() {
169                    return Ok(Bsel::B3);
170                }
171                stream.set_position(saved_pos);
172            }
173            stream.set_position(saved_pos);
174            let saved_pos = stream.position();
175            // Try H0
176            {
177                let saved_pos = stream.position();
178                if stream.expect_string(".h0").is_ok() {
179                    return Ok(Bsel::H0);
180                }
181                stream.set_position(saved_pos);
182            }
183            stream.set_position(saved_pos);
184            let saved_pos = stream.position();
185            // Try H1
186            {
187                let saved_pos = stream.position();
188                if stream.expect_string(".h1").is_ok() {
189                    return Ok(Bsel::H1);
190                }
191                stream.set_position(saved_pos);
192            }
193            stream.set_position(saved_pos);
194            let span = stream
195                .peek()
196                .map(|(_, s)| s.clone())
197                .unwrap_or(Span { start: 0, end: 0 });
198            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
199            let found = stream
200                .peek()
201                .map(|(t, _)| format!("{:?}", t))
202                .unwrap_or_else(|_| "<end of input>".to_string());
203            Err(crate::parser::unexpected_value(span, expected, found))
204        }
205    }
206
207    impl PtxParser for Dsel {
208        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
209            // Try B0
210            {
211                let saved_pos = stream.position();
212                if stream.expect_string(".b0").is_ok() {
213                    return Ok(Dsel::B0);
214                }
215                stream.set_position(saved_pos);
216            }
217            let saved_pos = stream.position();
218            // Try B1
219            {
220                let saved_pos = stream.position();
221                if stream.expect_string(".b1").is_ok() {
222                    return Ok(Dsel::B1);
223                }
224                stream.set_position(saved_pos);
225            }
226            stream.set_position(saved_pos);
227            let saved_pos = stream.position();
228            // Try B2
229            {
230                let saved_pos = stream.position();
231                if stream.expect_string(".b2").is_ok() {
232                    return Ok(Dsel::B2);
233                }
234                stream.set_position(saved_pos);
235            }
236            stream.set_position(saved_pos);
237            let saved_pos = stream.position();
238            // Try B3
239            {
240                let saved_pos = stream.position();
241                if stream.expect_string(".b3").is_ok() {
242                    return Ok(Dsel::B3);
243                }
244                stream.set_position(saved_pos);
245            }
246            stream.set_position(saved_pos);
247            let saved_pos = stream.position();
248            // Try H0
249            {
250                let saved_pos = stream.position();
251                if stream.expect_string(".h0").is_ok() {
252                    return Ok(Dsel::H0);
253                }
254                stream.set_position(saved_pos);
255            }
256            stream.set_position(saved_pos);
257            let saved_pos = stream.position();
258            // Try H1
259            {
260                let saved_pos = stream.position();
261                if stream.expect_string(".h1").is_ok() {
262                    return Ok(Dsel::H1);
263                }
264                stream.set_position(saved_pos);
265            }
266            stream.set_position(saved_pos);
267            let span = stream
268                .peek()
269                .map(|(_, s)| s.clone())
270                .unwrap_or(Span { start: 0, end: 0 });
271            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
272            let found = stream
273                .peek()
274                .map(|(t, _)| format!("{:?}", t))
275                .unwrap_or_else(|_| "<end of input>".to_string());
276            Err(crate::parser::unexpected_value(span, expected, found))
277        }
278    }
279
280    impl PtxParser for Dtype {
281        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
282            // Try U32
283            {
284                let saved_pos = stream.position();
285                if stream.expect_string(".u32").is_ok() {
286                    return Ok(Dtype::U32);
287                }
288                stream.set_position(saved_pos);
289            }
290            let saved_pos = stream.position();
291            // Try S32
292            {
293                let saved_pos = stream.position();
294                if stream.expect_string(".s32").is_ok() {
295                    return Ok(Dtype::S32);
296                }
297                stream.set_position(saved_pos);
298            }
299            stream.set_position(saved_pos);
300            let span = stream
301                .peek()
302                .map(|(_, s)| s.clone())
303                .unwrap_or(Span { start: 0, end: 0 });
304            let expected = &[".u32", ".s32"];
305            let found = stream
306                .peek()
307                .map(|(t, _)| format!("{:?}", t))
308                .unwrap_or_else(|_| "<end of input>".to_string());
309            Err(crate::parser::unexpected_value(span, expected, found))
310        }
311    }
312
313    impl PtxParser for Mode {
314        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
315            // Try Clamp
316            {
317                let saved_pos = stream.position();
318                if stream.expect_string(".clamp").is_ok() {
319                    return Ok(Mode::Clamp);
320                }
321                stream.set_position(saved_pos);
322            }
323            let saved_pos = stream.position();
324            // Try Wrap
325            {
326                let saved_pos = stream.position();
327                if stream.expect_string(".wrap").is_ok() {
328                    return Ok(Mode::Wrap);
329                }
330                stream.set_position(saved_pos);
331            }
332            stream.set_position(saved_pos);
333            let span = stream
334                .peek()
335                .map(|(_, s)| s.clone())
336                .unwrap_or(Span { start: 0, end: 0 });
337            let expected = &[".clamp", ".wrap"];
338            let found = stream
339                .peek()
340                .map(|(t, _)| format!("{:?}", t))
341                .unwrap_or_else(|_| "<end of input>".to_string());
342            Err(crate::parser::unexpected_value(span, expected, found))
343        }
344    }
345
346    impl PtxParser for Op2 {
347        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
348            // Try Add
349            {
350                let saved_pos = stream.position();
351                if stream.expect_string(".add").is_ok() {
352                    return Ok(Op2::Add);
353                }
354                stream.set_position(saved_pos);
355            }
356            let saved_pos = stream.position();
357            // Try Min
358            {
359                let saved_pos = stream.position();
360                if stream.expect_string(".min").is_ok() {
361                    return Ok(Op2::Min);
362                }
363                stream.set_position(saved_pos);
364            }
365            stream.set_position(saved_pos);
366            let saved_pos = stream.position();
367            // Try Max
368            {
369                let saved_pos = stream.position();
370                if stream.expect_string(".max").is_ok() {
371                    return Ok(Op2::Max);
372                }
373                stream.set_position(saved_pos);
374            }
375            stream.set_position(saved_pos);
376            let span = stream
377                .peek()
378                .map(|(_, s)| s.clone())
379                .unwrap_or(Span { start: 0, end: 0 });
380            let expected = &[".add", ".min", ".max"];
381            let found = stream
382                .peek()
383                .map(|(t, _)| format!("{:?}", t))
384                .unwrap_or_else(|_| "<end of input>".to_string());
385            Err(crate::parser::unexpected_value(span, expected, found))
386        }
387    }
388
389    impl PtxParser for VshlDtypeAtypeU32SatMode {
390        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
391            stream.expect_string("vshl")?;
392            let dtype = Dtype::parse(stream)?;
393            stream.expect_complete()?;
394            let atype = Atype::parse(stream)?;
395            stream.expect_complete()?;
396            stream.expect_string(".u32")?;
397            let u32 = ();
398            stream.expect_complete()?;
399            let saved_pos = stream.position();
400            let sat = stream.expect_string(".sat").is_ok();
401            if !sat {
402                stream.set_position(saved_pos);
403            }
404            stream.expect_complete()?;
405            let mode = Mode::parse(stream)?;
406            stream.expect_complete()?;
407            let d = GeneralOperand::parse(stream)?;
408            stream.expect_complete()?;
409            stream.expect(&PtxToken::Comma)?;
410            let a = GeneralOperand::parse(stream)?;
411            let saved_pos = stream.position();
412            let asel = match Asel::parse(stream) {
413                Ok(val) => Some(val),
414                Err(_) => {
415                    stream.set_position(saved_pos);
416                    None
417                }
418            };
419            stream.expect_complete()?;
420            stream.expect(&PtxToken::Comma)?;
421            let b = GeneralOperand::parse(stream)?;
422            let saved_pos = stream.position();
423            let bsel = match Bsel::parse(stream) {
424                Ok(val) => Some(val),
425                Err(_) => {
426                    stream.set_position(saved_pos);
427                    None
428                }
429            };
430            stream.expect_complete()?;
431            stream.expect_complete()?;
432            stream.expect(&PtxToken::Semicolon)?;
433            Ok(VshlDtypeAtypeU32SatMode {
434                dtype,
435                atype,
436                u32,
437                sat,
438                mode,
439                d,
440                a,
441                asel,
442                b,
443                bsel,
444            })
445        }
446    }
447
448    impl PtxParser for VshrDtypeAtypeU32SatMode {
449        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
450            stream.expect_string("vshr")?;
451            let dtype = Dtype::parse(stream)?;
452            stream.expect_complete()?;
453            let atype = Atype::parse(stream)?;
454            stream.expect_complete()?;
455            stream.expect_string(".u32")?;
456            let u32 = ();
457            stream.expect_complete()?;
458            let saved_pos = stream.position();
459            let sat = stream.expect_string(".sat").is_ok();
460            if !sat {
461                stream.set_position(saved_pos);
462            }
463            stream.expect_complete()?;
464            let mode = Mode::parse(stream)?;
465            stream.expect_complete()?;
466            let d = GeneralOperand::parse(stream)?;
467            stream.expect_complete()?;
468            stream.expect(&PtxToken::Comma)?;
469            let a = GeneralOperand::parse(stream)?;
470            let saved_pos = stream.position();
471            let asel = match Asel::parse(stream) {
472                Ok(val) => Some(val),
473                Err(_) => {
474                    stream.set_position(saved_pos);
475                    None
476                }
477            };
478            stream.expect_complete()?;
479            stream.expect(&PtxToken::Comma)?;
480            let b = GeneralOperand::parse(stream)?;
481            let saved_pos = stream.position();
482            let bsel = match Bsel::parse(stream) {
483                Ok(val) => Some(val),
484                Err(_) => {
485                    stream.set_position(saved_pos);
486                    None
487                }
488            };
489            stream.expect_complete()?;
490            stream.expect_complete()?;
491            stream.expect(&PtxToken::Semicolon)?;
492            Ok(VshrDtypeAtypeU32SatMode {
493                dtype,
494                atype,
495                u32,
496                sat,
497                mode,
498                d,
499                a,
500                asel,
501                b,
502                bsel,
503            })
504        }
505    }
506
507    impl PtxParser for VshlDtypeAtypeU32SatModeOp2 {
508        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
509            stream.expect_string("vshl")?;
510            let dtype = Dtype::parse(stream)?;
511            stream.expect_complete()?;
512            let atype = Atype::parse(stream)?;
513            stream.expect_complete()?;
514            stream.expect_string(".u32")?;
515            let u32 = ();
516            stream.expect_complete()?;
517            let saved_pos = stream.position();
518            let sat = stream.expect_string(".sat").is_ok();
519            if !sat {
520                stream.set_position(saved_pos);
521            }
522            stream.expect_complete()?;
523            let mode = Mode::parse(stream)?;
524            stream.expect_complete()?;
525            let op2 = Op2::parse(stream)?;
526            stream.expect_complete()?;
527            let d = GeneralOperand::parse(stream)?;
528            stream.expect_complete()?;
529            stream.expect(&PtxToken::Comma)?;
530            let a = GeneralOperand::parse(stream)?;
531            let saved_pos = stream.position();
532            let asel = match Asel::parse(stream) {
533                Ok(val) => Some(val),
534                Err(_) => {
535                    stream.set_position(saved_pos);
536                    None
537                }
538            };
539            stream.expect_complete()?;
540            stream.expect(&PtxToken::Comma)?;
541            let b = GeneralOperand::parse(stream)?;
542            let saved_pos = stream.position();
543            let bsel = match Bsel::parse(stream) {
544                Ok(val) => Some(val),
545                Err(_) => {
546                    stream.set_position(saved_pos);
547                    None
548                }
549            };
550            stream.expect_complete()?;
551            stream.expect(&PtxToken::Comma)?;
552            let c = GeneralOperand::parse(stream)?;
553            stream.expect_complete()?;
554            stream.expect_complete()?;
555            stream.expect(&PtxToken::Semicolon)?;
556            Ok(VshlDtypeAtypeU32SatModeOp2 {
557                dtype,
558                atype,
559                u32,
560                sat,
561                mode,
562                op2,
563                d,
564                a,
565                asel,
566                b,
567                bsel,
568                c,
569            })
570        }
571    }
572
573    impl PtxParser for VshrDtypeAtypeU32SatModeOp2 {
574        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
575            stream.expect_string("vshr")?;
576            let dtype = Dtype::parse(stream)?;
577            stream.expect_complete()?;
578            let atype = Atype::parse(stream)?;
579            stream.expect_complete()?;
580            stream.expect_string(".u32")?;
581            let u32 = ();
582            stream.expect_complete()?;
583            let saved_pos = stream.position();
584            let sat = stream.expect_string(".sat").is_ok();
585            if !sat {
586                stream.set_position(saved_pos);
587            }
588            stream.expect_complete()?;
589            let mode = Mode::parse(stream)?;
590            stream.expect_complete()?;
591            let op2 = Op2::parse(stream)?;
592            stream.expect_complete()?;
593            let d = GeneralOperand::parse(stream)?;
594            stream.expect_complete()?;
595            stream.expect(&PtxToken::Comma)?;
596            let a = GeneralOperand::parse(stream)?;
597            let saved_pos = stream.position();
598            let asel = match Asel::parse(stream) {
599                Ok(val) => Some(val),
600                Err(_) => {
601                    stream.set_position(saved_pos);
602                    None
603                }
604            };
605            stream.expect_complete()?;
606            stream.expect(&PtxToken::Comma)?;
607            let b = GeneralOperand::parse(stream)?;
608            let saved_pos = stream.position();
609            let bsel = match Bsel::parse(stream) {
610                Ok(val) => Some(val),
611                Err(_) => {
612                    stream.set_position(saved_pos);
613                    None
614                }
615            };
616            stream.expect_complete()?;
617            stream.expect(&PtxToken::Comma)?;
618            let c = GeneralOperand::parse(stream)?;
619            stream.expect_complete()?;
620            stream.expect_complete()?;
621            stream.expect(&PtxToken::Semicolon)?;
622            Ok(VshrDtypeAtypeU32SatModeOp2 {
623                dtype,
624                atype,
625                u32,
626                sat,
627                mode,
628                op2,
629                d,
630                a,
631                asel,
632                b,
633                bsel,
634                c,
635            })
636        }
637    }
638
639    impl PtxParser for VshlDtypeAtypeU32SatMode1 {
640        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
641            stream.expect_string("vshl")?;
642            let dtype = Dtype::parse(stream)?;
643            stream.expect_complete()?;
644            let atype = Atype::parse(stream)?;
645            stream.expect_complete()?;
646            stream.expect_string(".u32")?;
647            let u32 = ();
648            stream.expect_complete()?;
649            let saved_pos = stream.position();
650            let sat = stream.expect_string(".sat").is_ok();
651            if !sat {
652                stream.set_position(saved_pos);
653            }
654            stream.expect_complete()?;
655            let mode = Mode::parse(stream)?;
656            stream.expect_complete()?;
657            let d = GeneralOperand::parse(stream)?;
658            let dsel = Dsel::parse(stream)?;
659            stream.expect_complete()?;
660            stream.expect(&PtxToken::Comma)?;
661            let a = GeneralOperand::parse(stream)?;
662            let saved_pos = stream.position();
663            let asel = match Asel::parse(stream) {
664                Ok(val) => Some(val),
665                Err(_) => {
666                    stream.set_position(saved_pos);
667                    None
668                }
669            };
670            stream.expect_complete()?;
671            stream.expect(&PtxToken::Comma)?;
672            let b = GeneralOperand::parse(stream)?;
673            let saved_pos = stream.position();
674            let bsel = match Bsel::parse(stream) {
675                Ok(val) => Some(val),
676                Err(_) => {
677                    stream.set_position(saved_pos);
678                    None
679                }
680            };
681            stream.expect_complete()?;
682            stream.expect(&PtxToken::Comma)?;
683            let c = GeneralOperand::parse(stream)?;
684            stream.expect_complete()?;
685            stream.expect_complete()?;
686            stream.expect(&PtxToken::Semicolon)?;
687            Ok(VshlDtypeAtypeU32SatMode1 {
688                dtype,
689                atype,
690                u32,
691                sat,
692                mode,
693                d,
694                dsel,
695                a,
696                asel,
697                b,
698                bsel,
699                c,
700            })
701        }
702    }
703
704    impl PtxParser for VshrDtypeAtypeU32SatMode1 {
705        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
706            stream.expect_string("vshr")?;
707            let dtype = Dtype::parse(stream)?;
708            stream.expect_complete()?;
709            let atype = Atype::parse(stream)?;
710            stream.expect_complete()?;
711            stream.expect_string(".u32")?;
712            let u32 = ();
713            stream.expect_complete()?;
714            let saved_pos = stream.position();
715            let sat = stream.expect_string(".sat").is_ok();
716            if !sat {
717                stream.set_position(saved_pos);
718            }
719            stream.expect_complete()?;
720            let mode = Mode::parse(stream)?;
721            stream.expect_complete()?;
722            let d = GeneralOperand::parse(stream)?;
723            let dsel = Dsel::parse(stream)?;
724            stream.expect_complete()?;
725            stream.expect(&PtxToken::Comma)?;
726            let a = GeneralOperand::parse(stream)?;
727            let saved_pos = stream.position();
728            let asel = match Asel::parse(stream) {
729                Ok(val) => Some(val),
730                Err(_) => {
731                    stream.set_position(saved_pos);
732                    None
733                }
734            };
735            stream.expect_complete()?;
736            stream.expect(&PtxToken::Comma)?;
737            let b = GeneralOperand::parse(stream)?;
738            let saved_pos = stream.position();
739            let bsel = match Bsel::parse(stream) {
740                Ok(val) => Some(val),
741                Err(_) => {
742                    stream.set_position(saved_pos);
743                    None
744                }
745            };
746            stream.expect_complete()?;
747            stream.expect(&PtxToken::Comma)?;
748            let c = GeneralOperand::parse(stream)?;
749            stream.expect_complete()?;
750            stream.expect_complete()?;
751            stream.expect(&PtxToken::Semicolon)?;
752            Ok(VshrDtypeAtypeU32SatMode1 {
753                dtype,
754                atype,
755                u32,
756                sat,
757                mode,
758                d,
759                dsel,
760                a,
761                asel,
762                b,
763                bsel,
764                c,
765            })
766        }
767    }
768}
ptx_parser/parser/instruction/vsh.rs

ptx_parser/parser/instruction/
vsh.rs
