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
86                .peek()
87                .map(|(_, s)| s.clone())
88                .unwrap_or(Span { start: 0, end: 0 });
89            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
90            let found = stream
91                .peek()
92                .map(|(t, _)| format!("{:?}", t))
93                .unwrap_or_else(|_| "<end of input>".to_string());
94            Err(crate::parser::unexpected_value(span, expected, found))
95        }
96    }
97
98    impl PtxParser for Atype {
99        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
100            // Try U32
101            {
102                let saved_pos = stream.position();
103                if stream.expect_string(".u32").is_ok() {
104                    return Ok(Atype::U32);
105                }
106                stream.set_position(saved_pos);
107            }
108            let saved_pos = stream.position();
109            // Try S32
110            {
111                let saved_pos = stream.position();
112                if stream.expect_string(".s32").is_ok() {
113                    return Ok(Atype::S32);
114                }
115                stream.set_position(saved_pos);
116            }
117            stream.set_position(saved_pos);
118            let span = stream
119                .peek()
120                .map(|(_, s)| s.clone())
121                .unwrap_or(Span { start: 0, end: 0 });
122            let expected = &[".u32", ".s32"];
123            let found = stream
124                .peek()
125                .map(|(t, _)| format!("{:?}", t))
126                .unwrap_or_else(|_| "<end of input>".to_string());
127            Err(crate::parser::unexpected_value(span, expected, found))
128        }
129    }
130
131    impl PtxParser for Bsel {
132        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
133            // Try B0
134            {
135                let saved_pos = stream.position();
136                if stream.expect_string(".b0").is_ok() {
137                    return Ok(Bsel::B0);
138                }
139                stream.set_position(saved_pos);
140            }
141            let saved_pos = stream.position();
142            // Try B1
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".b1").is_ok() {
146                    return Ok(Bsel::B1);
147                }
148                stream.set_position(saved_pos);
149            }
150            stream.set_position(saved_pos);
151            let saved_pos = stream.position();
152            // Try B2
153            {
154                let saved_pos = stream.position();
155                if stream.expect_string(".b2").is_ok() {
156                    return Ok(Bsel::B2);
157                }
158                stream.set_position(saved_pos);
159            }
160            stream.set_position(saved_pos);
161            let saved_pos = stream.position();
162            // Try B3
163            {
164                let saved_pos = stream.position();
165                if stream.expect_string(".b3").is_ok() {
166                    return Ok(Bsel::B3);
167                }
168                stream.set_position(saved_pos);
169            }
170            stream.set_position(saved_pos);
171            let saved_pos = stream.position();
172            // Try H0
173            {
174                let saved_pos = stream.position();
175                if stream.expect_string(".h0").is_ok() {
176                    return Ok(Bsel::H0);
177                }
178                stream.set_position(saved_pos);
179            }
180            stream.set_position(saved_pos);
181            let saved_pos = stream.position();
182            // Try H1
183            {
184                let saved_pos = stream.position();
185                if stream.expect_string(".h1").is_ok() {
186                    return Ok(Bsel::H1);
187                }
188                stream.set_position(saved_pos);
189            }
190            stream.set_position(saved_pos);
191            let span = stream
192                .peek()
193                .map(|(_, s)| s.clone())
194                .unwrap_or(Span { start: 0, end: 0 });
195            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
196            let found = stream
197                .peek()
198                .map(|(t, _)| format!("{:?}", t))
199                .unwrap_or_else(|_| "<end of input>".to_string());
200            Err(crate::parser::unexpected_value(span, expected, found))
201        }
202    }
203
204    impl PtxParser for Btype {
205        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
206            // Try U32
207            {
208                let saved_pos = stream.position();
209                if stream.expect_string(".u32").is_ok() {
210                    return Ok(Btype::U32);
211                }
212                stream.set_position(saved_pos);
213            }
214            let saved_pos = stream.position();
215            // Try S32
216            {
217                let saved_pos = stream.position();
218                if stream.expect_string(".s32").is_ok() {
219                    return Ok(Btype::S32);
220                }
221                stream.set_position(saved_pos);
222            }
223            stream.set_position(saved_pos);
224            let span = stream
225                .peek()
226                .map(|(_, s)| s.clone())
227                .unwrap_or(Span { start: 0, end: 0 });
228            let expected = &[".u32", ".s32"];
229            let found = stream
230                .peek()
231                .map(|(t, _)| format!("{:?}", t))
232                .unwrap_or_else(|_| "<end of input>".to_string());
233            Err(crate::parser::unexpected_value(span, expected, found))
234        }
235    }
236
237    impl PtxParser for Dtype {
238        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
239            // Try U32
240            {
241                let saved_pos = stream.position();
242                if stream.expect_string(".u32").is_ok() {
243                    return Ok(Dtype::U32);
244                }
245                stream.set_position(saved_pos);
246            }
247            let saved_pos = stream.position();
248            // Try S32
249            {
250                let saved_pos = stream.position();
251                if stream.expect_string(".s32").is_ok() {
252                    return Ok(Dtype::S32);
253                }
254                stream.set_position(saved_pos);
255            }
256            stream.set_position(saved_pos);
257            let span = stream
258                .peek()
259                .map(|(_, s)| s.clone())
260                .unwrap_or(Span { start: 0, end: 0 });
261            let expected = &[".u32", ".s32"];
262            let found = stream
263                .peek()
264                .map(|(t, _)| format!("{:?}", t))
265                .unwrap_or_else(|_| "<end of input>".to_string());
266            Err(crate::parser::unexpected_value(span, expected, found))
267        }
268    }
269
270    impl PtxParser for Scale {
271        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
272            // Try Shr15
273            {
274                let saved_pos = stream.position();
275                if stream.expect_string(".shr15").is_ok() {
276                    return Ok(Scale::Shr15);
277                }
278                stream.set_position(saved_pos);
279            }
280            let saved_pos = stream.position();
281            // Try Shr7
282            {
283                let saved_pos = stream.position();
284                if stream.expect_string(".shr7").is_ok() {
285                    return Ok(Scale::Shr7);
286                }
287                stream.set_position(saved_pos);
288            }
289            stream.set_position(saved_pos);
290            let span = stream
291                .peek()
292                .map(|(_, s)| s.clone())
293                .unwrap_or(Span { start: 0, end: 0 });
294            let expected = &[".shr15", ".shr7"];
295            let found = stream
296                .peek()
297                .map(|(t, _)| format!("{:?}", t))
298                .unwrap_or_else(|_| "<end of input>".to_string());
299            Err(crate::parser::unexpected_value(span, expected, found))
300        }
301    }
302
303    impl PtxParser for VmadDtypeAtypeBtypeSatScale {
304        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
305            stream.expect_string("vmad")?;
306            let dtype = Dtype::parse(stream)?;
307            stream.expect_complete()?;
308            let atype = Atype::parse(stream)?;
309            stream.expect_complete()?;
310            let btype = Btype::parse(stream)?;
311            stream.expect_complete()?;
312            let saved_pos = stream.position();
313            let sat = stream.expect_string(".sat").is_ok();
314            if !sat {
315                stream.set_position(saved_pos);
316            }
317            stream.expect_complete()?;
318            let saved_pos = stream.position();
319            let scale = match Scale::parse(stream) {
320                Ok(val) => Some(val),
321                Err(_) => {
322                    stream.set_position(saved_pos);
323                    None
324                }
325            };
326            stream.expect_complete()?;
327            let d = GeneralOperand::parse(stream)?;
328            stream.expect_complete()?;
329            stream.expect(&PtxToken::Comma)?;
330            let a_op = stream
331                .consume_if(|t| matches!(t, PtxToken::Minus))
332                .is_some();
333            let a = GeneralOperand::parse(stream)?;
334            let saved_pos = stream.position();
335            let asel = match Asel::parse(stream) {
336                Ok(val) => Some(val),
337                Err(_) => {
338                    stream.set_position(saved_pos);
339                    None
340                }
341            };
342            stream.expect_complete()?;
343            stream.expect(&PtxToken::Comma)?;
344            let b_op = stream
345                .consume_if(|t| matches!(t, PtxToken::Minus))
346                .is_some();
347            let b = GeneralOperand::parse(stream)?;
348            let saved_pos = stream.position();
349            let bsel = match Bsel::parse(stream) {
350                Ok(val) => Some(val),
351                Err(_) => {
352                    stream.set_position(saved_pos);
353                    None
354                }
355            };
356            stream.expect_complete()?;
357            stream.expect(&PtxToken::Comma)?;
358            let c_op = stream
359                .consume_if(|t| matches!(t, PtxToken::Minus))
360                .is_some();
361            let c = GeneralOperand::parse(stream)?;
362            stream.expect_complete()?;
363            stream.expect_complete()?;
364            stream.expect(&PtxToken::Semicolon)?;
365            Ok(VmadDtypeAtypeBtypeSatScale {
366                dtype,
367                atype,
368                btype,
369                sat,
370                scale,
371                d,
372                a_op,
373                a,
374                asel,
375                b_op,
376                b,
377                bsel,
378                c_op,
379                c,
380            })
381        }
382    }
383
384    impl PtxParser for VmadDtypeAtypeBtypePoSatScale {
385        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
386            stream.expect_string("vmad")?;
387            let dtype = Dtype::parse(stream)?;
388            stream.expect_complete()?;
389            let atype = Atype::parse(stream)?;
390            stream.expect_complete()?;
391            let btype = Btype::parse(stream)?;
392            stream.expect_complete()?;
393            stream.expect_string(".po")?;
394            let po = ();
395            stream.expect_complete()?;
396            let saved_pos = stream.position();
397            let sat = stream.expect_string(".sat").is_ok();
398            if !sat {
399                stream.set_position(saved_pos);
400            }
401            stream.expect_complete()?;
402            let saved_pos = stream.position();
403            let scale = match Scale::parse(stream) {
404                Ok(val) => Some(val),
405                Err(_) => {
406                    stream.set_position(saved_pos);
407                    None
408                }
409            };
410            stream.expect_complete()?;
411            let d = GeneralOperand::parse(stream)?;
412            stream.expect_complete()?;
413            stream.expect(&PtxToken::Comma)?;
414            let a = GeneralOperand::parse(stream)?;
415            let saved_pos = stream.position();
416            let asel = match Asel::parse(stream) {
417                Ok(val) => Some(val),
418                Err(_) => {
419                    stream.set_position(saved_pos);
420                    None
421                }
422            };
423            stream.expect_complete()?;
424            stream.expect(&PtxToken::Comma)?;
425            let b = GeneralOperand::parse(stream)?;
426            let saved_pos = stream.position();
427            let bsel = match Bsel::parse(stream) {
428                Ok(val) => Some(val),
429                Err(_) => {
430                    stream.set_position(saved_pos);
431                    None
432                }
433            };
434            stream.expect_complete()?;
435            stream.expect(&PtxToken::Comma)?;
436            let c = GeneralOperand::parse(stream)?;
437            stream.expect_complete()?;
438            stream.expect_complete()?;
439            stream.expect(&PtxToken::Semicolon)?;
440            Ok(VmadDtypeAtypeBtypePoSatScale {
441                dtype,
442                atype,
443                btype,
444                po,
445                sat,
446                scale,
447                d,
448                a,
449                asel,
450                b,
451                bsel,
452                c,
453            })
454        }
455    }
456}
ptx_parser/parser/instruction/vmad.rs

ptx_parser/parser/instruction/
vmad.rs
