ptx_parser/parser/instruction/
vmad.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation
4//! vmad.dtype.atype.btype{.sat}{.scale}     d, {-}a{.asel}, {-}b{.bsel},
5//! {-}c;
6//! vmad.dtype.atype.btype.po{.sat}{.scale}  d, a{.asel}, b{.bsel}, c;
7//! .dtype = .atype = .btype = { .u32, .s32 };
8//! .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
9//! .scale = { .shr7, .shr15 };
10
11#![allow(unused)]
12
13use crate::lexer::PtxToken;
14use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
15use crate::r#type::common::*;
16
17pub mod section_0 {
18    use super::*;
19    use crate::r#type::instruction::vmad::section_0::*;
20
21    // ============================================================================
22    // Generated enum parsers
23    // ============================================================================
24
25    impl PtxParser for Asel {
26        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
27            // Try B0
28            {
29                let saved_pos = stream.position();
30                if stream.expect_string(".b0").is_ok() {
31                    return Ok(Asel::B0);
32                }
33                stream.set_position(saved_pos);
34            }
35            let saved_pos = stream.position();
36            // Try B1
37            {
38                let saved_pos = stream.position();
39                if stream.expect_string(".b1").is_ok() {
40                    return Ok(Asel::B1);
41                }
42                stream.set_position(saved_pos);
43            }
44            stream.set_position(saved_pos);
45            let saved_pos = stream.position();
46            // Try B2
47            {
48                let saved_pos = stream.position();
49                if stream.expect_string(".b2").is_ok() {
50                    return Ok(Asel::B2);
51                }
52                stream.set_position(saved_pos);
53            }
54            stream.set_position(saved_pos);
55            let saved_pos = stream.position();
56            // Try B3
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".b3").is_ok() {
60                    return Ok(Asel::B3);
61                }
62                stream.set_position(saved_pos);
63            }
64            stream.set_position(saved_pos);
65            let saved_pos = stream.position();
66            // Try H0
67            {
68                let saved_pos = stream.position();
69                if stream.expect_string(".h0").is_ok() {
70                    return Ok(Asel::H0);
71                }
72                stream.set_position(saved_pos);
73            }
74            stream.set_position(saved_pos);
75            let saved_pos = stream.position();
76            // Try H1
77            {
78                let saved_pos = stream.position();
79                if stream.expect_string(".h1").is_ok() {
80                    return Ok(Asel::H1);
81                }
82                stream.set_position(saved_pos);
83            }
84            stream.set_position(saved_pos);
85            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
86            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
87            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
88            Err(crate::parser::unexpected_value(span, expected, found))
89        }
90    }
91
92    impl PtxParser for Atype {
93        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
94            // Try U32
95            {
96                let saved_pos = stream.position();
97                if stream.expect_string(".u32").is_ok() {
98                    return Ok(Atype::U32);
99                }
100                stream.set_position(saved_pos);
101            }
102            let saved_pos = stream.position();
103            // Try S32
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".s32").is_ok() {
107                    return Ok(Atype::S32);
108                }
109                stream.set_position(saved_pos);
110            }
111            stream.set_position(saved_pos);
112            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
113            let expected = &[".u32", ".s32"];
114            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
115            Err(crate::parser::unexpected_value(span, expected, found))
116        }
117    }
118
119    impl PtxParser for Bsel {
120        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
121            // Try B0
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".b0").is_ok() {
125                    return Ok(Bsel::B0);
126                }
127                stream.set_position(saved_pos);
128            }
129            let saved_pos = stream.position();
130            // Try B1
131            {
132                let saved_pos = stream.position();
133                if stream.expect_string(".b1").is_ok() {
134                    return Ok(Bsel::B1);
135                }
136                stream.set_position(saved_pos);
137            }
138            stream.set_position(saved_pos);
139            let saved_pos = stream.position();
140            // Try B2
141            {
142                let saved_pos = stream.position();
143                if stream.expect_string(".b2").is_ok() {
144                    return Ok(Bsel::B2);
145                }
146                stream.set_position(saved_pos);
147            }
148            stream.set_position(saved_pos);
149            let saved_pos = stream.position();
150            // Try B3
151            {
152                let saved_pos = stream.position();
153                if stream.expect_string(".b3").is_ok() {
154                    return Ok(Bsel::B3);
155                }
156                stream.set_position(saved_pos);
157            }
158            stream.set_position(saved_pos);
159            let saved_pos = stream.position();
160            // Try H0
161            {
162                let saved_pos = stream.position();
163                if stream.expect_string(".h0").is_ok() {
164                    return Ok(Bsel::H0);
165                }
166                stream.set_position(saved_pos);
167            }
168            stream.set_position(saved_pos);
169            let saved_pos = stream.position();
170            // Try H1
171            {
172                let saved_pos = stream.position();
173                if stream.expect_string(".h1").is_ok() {
174                    return Ok(Bsel::H1);
175                }
176                stream.set_position(saved_pos);
177            }
178            stream.set_position(saved_pos);
179            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
180            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
181            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
182            Err(crate::parser::unexpected_value(span, expected, found))
183        }
184    }
185
186    impl PtxParser for Btype {
187        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
188            // Try U32
189            {
190                let saved_pos = stream.position();
191                if stream.expect_string(".u32").is_ok() {
192                    return Ok(Btype::U32);
193                }
194                stream.set_position(saved_pos);
195            }
196            let saved_pos = stream.position();
197            // Try S32
198            {
199                let saved_pos = stream.position();
200                if stream.expect_string(".s32").is_ok() {
201                    return Ok(Btype::S32);
202                }
203                stream.set_position(saved_pos);
204            }
205            stream.set_position(saved_pos);
206            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
207            let expected = &[".u32", ".s32"];
208            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
209            Err(crate::parser::unexpected_value(span, expected, found))
210        }
211    }
212
213    impl PtxParser for Dtype {
214        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
215            // Try U32
216            {
217                let saved_pos = stream.position();
218                if stream.expect_string(".u32").is_ok() {
219                    return Ok(Dtype::U32);
220                }
221                stream.set_position(saved_pos);
222            }
223            let saved_pos = stream.position();
224            // Try S32
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".s32").is_ok() {
228                    return Ok(Dtype::S32);
229                }
230                stream.set_position(saved_pos);
231            }
232            stream.set_position(saved_pos);
233            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
234            let expected = &[".u32", ".s32"];
235            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
236            Err(crate::parser::unexpected_value(span, expected, found))
237        }
238    }
239
240    impl PtxParser for Scale {
241        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
242            // Try Shr15
243            {
244                let saved_pos = stream.position();
245                if stream.expect_string(".shr15").is_ok() {
246                    return Ok(Scale::Shr15);
247                }
248                stream.set_position(saved_pos);
249            }
250            let saved_pos = stream.position();
251            // Try Shr7
252            {
253                let saved_pos = stream.position();
254                if stream.expect_string(".shr7").is_ok() {
255                    return Ok(Scale::Shr7);
256                }
257                stream.set_position(saved_pos);
258            }
259            stream.set_position(saved_pos);
260            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
261            let expected = &[".shr15", ".shr7"];
262            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
263            Err(crate::parser::unexpected_value(span, expected, found))
264        }
265    }
266
267    impl PtxParser for VmadDtypeAtypeBtypeSatScale {
268        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
269            stream.expect_string("vmad")?;
270            let dtype = Dtype::parse(stream)?;
271            stream.expect_complete()?;
272            let atype = Atype::parse(stream)?;
273            stream.expect_complete()?;
274            let btype = Btype::parse(stream)?;
275            stream.expect_complete()?;
276            let saved_pos = stream.position();
277            let sat = stream.expect_string(".sat").is_ok();
278            if !sat {
279                stream.set_position(saved_pos);
280            }
281            stream.expect_complete()?;
282            let saved_pos = stream.position();
283            let scale = match Scale::parse(stream) {
284                Ok(val) => Some(val),
285                Err(_) => {
286                    stream.set_position(saved_pos);
287                    None
288                }
289            };
290            stream.expect_complete()?;
291            let d = GeneralOperand::parse(stream)?;
292            stream.expect_complete()?;
293            stream.expect(&PtxToken::Comma)?;
294            let a_op = stream.consume_if(|t| matches!(t, PtxToken::Minus)).is_some();
295            let a = GeneralOperand::parse(stream)?;
296            let saved_pos = stream.position();
297            let asel = match Asel::parse(stream) {
298                Ok(val) => Some(val),
299                Err(_) => {
300                    stream.set_position(saved_pos);
301                    None
302                }
303            };
304            stream.expect_complete()?;
305            stream.expect(&PtxToken::Comma)?;
306            let b_op = stream.consume_if(|t| matches!(t, PtxToken::Minus)).is_some();
307            let b = GeneralOperand::parse(stream)?;
308            let saved_pos = stream.position();
309            let bsel = match Bsel::parse(stream) {
310                Ok(val) => Some(val),
311                Err(_) => {
312                    stream.set_position(saved_pos);
313                    None
314                }
315            };
316            stream.expect_complete()?;
317            stream.expect(&PtxToken::Comma)?;
318            let c_op = stream.consume_if(|t| matches!(t, PtxToken::Minus)).is_some();
319            let c = GeneralOperand::parse(stream)?;
320            stream.expect_complete()?;
321            stream.expect_complete()?;
322            stream.expect(&PtxToken::Semicolon)?;
323            Ok(VmadDtypeAtypeBtypeSatScale {
324                dtype,
325                atype,
326                btype,
327                sat,
328                scale,
329                d,
330                a_op,
331                a,
332                asel,
333                b_op,
334                b,
335                bsel,
336                c_op,
337                c,
338            })
339        }
340    }
341
342
343    impl PtxParser for VmadDtypeAtypeBtypePoSatScale {
344        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
345            stream.expect_string("vmad")?;
346            let dtype = Dtype::parse(stream)?;
347            stream.expect_complete()?;
348            let atype = Atype::parse(stream)?;
349            stream.expect_complete()?;
350            let btype = Btype::parse(stream)?;
351            stream.expect_complete()?;
352            stream.expect_string(".po")?;
353            let po = ();
354            stream.expect_complete()?;
355            let saved_pos = stream.position();
356            let sat = stream.expect_string(".sat").is_ok();
357            if !sat {
358                stream.set_position(saved_pos);
359            }
360            stream.expect_complete()?;
361            let saved_pos = stream.position();
362            let scale = match Scale::parse(stream) {
363                Ok(val) => Some(val),
364                Err(_) => {
365                    stream.set_position(saved_pos);
366                    None
367                }
368            };
369            stream.expect_complete()?;
370            let d = GeneralOperand::parse(stream)?;
371            stream.expect_complete()?;
372            stream.expect(&PtxToken::Comma)?;
373            let a = GeneralOperand::parse(stream)?;
374            let saved_pos = stream.position();
375            let asel = match Asel::parse(stream) {
376                Ok(val) => Some(val),
377                Err(_) => {
378                    stream.set_position(saved_pos);
379                    None
380                }
381            };
382            stream.expect_complete()?;
383            stream.expect(&PtxToken::Comma)?;
384            let b = GeneralOperand::parse(stream)?;
385            let saved_pos = stream.position();
386            let bsel = match Bsel::parse(stream) {
387                Ok(val) => Some(val),
388                Err(_) => {
389                    stream.set_position(saved_pos);
390                    None
391                }
392            };
393            stream.expect_complete()?;
394            stream.expect(&PtxToken::Comma)?;
395            let c = GeneralOperand::parse(stream)?;
396            stream.expect_complete()?;
397            stream.expect_complete()?;
398            stream.expect(&PtxToken::Semicolon)?;
399            Ok(VmadDtypeAtypeBtypePoSatScale {
400                dtype,
401                atype,
402                btype,
403                po,
404                sat,
405                scale,
406                d,
407                a,
408                asel,
409                b,
410                bsel,
411                c,
412            })
413        }
414    }
415
416
417}
418
ptx_parser/parser/instruction/vmad.rs

ptx_parser/parser/instruction/
vmad.rs
