ptx_parser/parser/instruction/
mad.rs

1//! Original PTX specification:
2//!
3//! mad.mode.type  d, a, b, c;
4//! mad.hi.sat.s32 d, a, b, c;
5//! .mode = { .hi, .lo, .wide };
6//! .type = { .u16, .u32, .u64,
7//! .s16, .s32, .s64 };
8//! 
9//! mad{.ftz}{.sat}.f32      d, a, b, c;    // .target sm_1x
10//! mad.rnd{.ftz}{.sat}.f32  d, a, b, c;    // .target sm_20
11//! mad.rnd.f64              d, a, b, c;    // .target sm_13 and higher
12//! .rnd = { .rn, .rz, .rm, .rp };
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::mad::section_0::*;
23
24    // ============================================================================
25    // Generated enum parsers
26    // ============================================================================
27
28    impl PtxParser for Mode {
29        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
30            // Try Wide
31            {
32                let saved_pos = stream.position();
33                if stream.expect_string(".wide").is_ok() {
34                    return Ok(Mode::Wide);
35                }
36                stream.set_position(saved_pos);
37            }
38            let saved_pos = stream.position();
39            // Try Hi
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".hi").is_ok() {
43                    return Ok(Mode::Hi);
44                }
45                stream.set_position(saved_pos);
46            }
47            stream.set_position(saved_pos);
48            let saved_pos = stream.position();
49            // Try Lo
50            {
51                let saved_pos = stream.position();
52                if stream.expect_string(".lo").is_ok() {
53                    return Ok(Mode::Lo);
54                }
55                stream.set_position(saved_pos);
56            }
57            stream.set_position(saved_pos);
58            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
59            let expected = &[".wide", ".hi", ".lo"];
60            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
61            Err(crate::parser::unexpected_value(span, expected, found))
62        }
63    }
64
65    impl PtxParser for Rnd {
66        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
67            // Try Rn
68            {
69                let saved_pos = stream.position();
70                if stream.expect_string(".rn").is_ok() {
71                    return Ok(Rnd::Rn);
72                }
73                stream.set_position(saved_pos);
74            }
75            let saved_pos = stream.position();
76            // Try Rz
77            {
78                let saved_pos = stream.position();
79                if stream.expect_string(".rz").is_ok() {
80                    return Ok(Rnd::Rz);
81                }
82                stream.set_position(saved_pos);
83            }
84            stream.set_position(saved_pos);
85            let saved_pos = stream.position();
86            // Try Rm
87            {
88                let saved_pos = stream.position();
89                if stream.expect_string(".rm").is_ok() {
90                    return Ok(Rnd::Rm);
91                }
92                stream.set_position(saved_pos);
93            }
94            stream.set_position(saved_pos);
95            let saved_pos = stream.position();
96            // Try Rp
97            {
98                let saved_pos = stream.position();
99                if stream.expect_string(".rp").is_ok() {
100                    return Ok(Rnd::Rp);
101                }
102                stream.set_position(saved_pos);
103            }
104            stream.set_position(saved_pos);
105            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
106            let expected = &[".rn", ".rz", ".rm", ".rp"];
107            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
108            Err(crate::parser::unexpected_value(span, expected, found))
109        }
110    }
111
112    impl PtxParser for Type {
113        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
114            // Try U16
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".u16").is_ok() {
118                    return Ok(Type::U16);
119                }
120                stream.set_position(saved_pos);
121            }
122            let saved_pos = stream.position();
123            // Try U32
124            {
125                let saved_pos = stream.position();
126                if stream.expect_string(".u32").is_ok() {
127                    return Ok(Type::U32);
128                }
129                stream.set_position(saved_pos);
130            }
131            stream.set_position(saved_pos);
132            let saved_pos = stream.position();
133            // Try U64
134            {
135                let saved_pos = stream.position();
136                if stream.expect_string(".u64").is_ok() {
137                    return Ok(Type::U64);
138                }
139                stream.set_position(saved_pos);
140            }
141            stream.set_position(saved_pos);
142            let saved_pos = stream.position();
143            // Try S16
144            {
145                let saved_pos = stream.position();
146                if stream.expect_string(".s16").is_ok() {
147                    return Ok(Type::S16);
148                }
149                stream.set_position(saved_pos);
150            }
151            stream.set_position(saved_pos);
152            let saved_pos = stream.position();
153            // Try S32
154            {
155                let saved_pos = stream.position();
156                if stream.expect_string(".s32").is_ok() {
157                    return Ok(Type::S32);
158                }
159                stream.set_position(saved_pos);
160            }
161            stream.set_position(saved_pos);
162            let saved_pos = stream.position();
163            // Try S64
164            {
165                let saved_pos = stream.position();
166                if stream.expect_string(".s64").is_ok() {
167                    return Ok(Type::S64);
168                }
169                stream.set_position(saved_pos);
170            }
171            stream.set_position(saved_pos);
172            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
173            let expected = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
174            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
175            Err(crate::parser::unexpected_value(span, expected, found))
176        }
177    }
178
179    impl PtxParser for MadModeType {
180        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
181            stream.expect_string("mad")?;
182            let mode = Mode::parse(stream)?;
183            stream.expect_complete()?;
184            let type_ = Type::parse(stream)?;
185            stream.expect_complete()?;
186            let d = GeneralOperand::parse(stream)?;
187            stream.expect_complete()?;
188            stream.expect(&PtxToken::Comma)?;
189            let a = GeneralOperand::parse(stream)?;
190            stream.expect_complete()?;
191            stream.expect(&PtxToken::Comma)?;
192            let b = GeneralOperand::parse(stream)?;
193            stream.expect_complete()?;
194            stream.expect(&PtxToken::Comma)?;
195            let c = GeneralOperand::parse(stream)?;
196            stream.expect_complete()?;
197            stream.expect_complete()?;
198            stream.expect(&PtxToken::Semicolon)?;
199            Ok(MadModeType {
200                mode,
201                type_,
202                d,
203                a,
204                b,
205                c,
206            })
207        }
208    }
209
210
211    impl PtxParser for MadHiSatS32 {
212        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
213            stream.expect_string("mad")?;
214            stream.expect_string(".hi")?;
215            let hi = ();
216            stream.expect_complete()?;
217            stream.expect_string(".sat")?;
218            let sat = ();
219            stream.expect_complete()?;
220            stream.expect_string(".s32")?;
221            let s32 = ();
222            stream.expect_complete()?;
223            let d = GeneralOperand::parse(stream)?;
224            stream.expect_complete()?;
225            stream.expect(&PtxToken::Comma)?;
226            let a = GeneralOperand::parse(stream)?;
227            stream.expect_complete()?;
228            stream.expect(&PtxToken::Comma)?;
229            let b = GeneralOperand::parse(stream)?;
230            stream.expect_complete()?;
231            stream.expect(&PtxToken::Comma)?;
232            let c = GeneralOperand::parse(stream)?;
233            stream.expect_complete()?;
234            stream.expect_complete()?;
235            stream.expect(&PtxToken::Semicolon)?;
236            Ok(MadHiSatS32 {
237                hi,
238                sat,
239                s32,
240                d,
241                a,
242                b,
243                c,
244            })
245        }
246    }
247
248
249    impl PtxParser for MadFtzSatF32 {
250        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
251            stream.expect_string("mad")?;
252            let saved_pos = stream.position();
253            let ftz = stream.expect_string(".ftz").is_ok();
254            if !ftz {
255                stream.set_position(saved_pos);
256            }
257            stream.expect_complete()?;
258            let saved_pos = stream.position();
259            let sat = stream.expect_string(".sat").is_ok();
260            if !sat {
261                stream.set_position(saved_pos);
262            }
263            stream.expect_complete()?;
264            stream.expect_string(".f32")?;
265            let f32 = ();
266            stream.expect_complete()?;
267            let d = GeneralOperand::parse(stream)?;
268            stream.expect_complete()?;
269            stream.expect(&PtxToken::Comma)?;
270            let a = GeneralOperand::parse(stream)?;
271            stream.expect_complete()?;
272            stream.expect(&PtxToken::Comma)?;
273            let b = GeneralOperand::parse(stream)?;
274            stream.expect_complete()?;
275            stream.expect(&PtxToken::Comma)?;
276            let c = GeneralOperand::parse(stream)?;
277            stream.expect_complete()?;
278            stream.expect_complete()?;
279            stream.expect(&PtxToken::Semicolon)?;
280            Ok(MadFtzSatF32 {
281                ftz,
282                sat,
283                f32,
284                d,
285                a,
286                b,
287                c,
288            })
289        }
290    }
291
292
293    impl PtxParser for MadRndFtzSatF32 {
294        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
295            stream.expect_string("mad")?;
296            let rnd = Rnd::parse(stream)?;
297            stream.expect_complete()?;
298            let saved_pos = stream.position();
299            let ftz = stream.expect_string(".ftz").is_ok();
300            if !ftz {
301                stream.set_position(saved_pos);
302            }
303            stream.expect_complete()?;
304            let saved_pos = stream.position();
305            let sat = stream.expect_string(".sat").is_ok();
306            if !sat {
307                stream.set_position(saved_pos);
308            }
309            stream.expect_complete()?;
310            stream.expect_string(".f32")?;
311            let f32 = ();
312            stream.expect_complete()?;
313            let d = GeneralOperand::parse(stream)?;
314            stream.expect_complete()?;
315            stream.expect(&PtxToken::Comma)?;
316            let a = GeneralOperand::parse(stream)?;
317            stream.expect_complete()?;
318            stream.expect(&PtxToken::Comma)?;
319            let b = GeneralOperand::parse(stream)?;
320            stream.expect_complete()?;
321            stream.expect(&PtxToken::Comma)?;
322            let c = GeneralOperand::parse(stream)?;
323            stream.expect_complete()?;
324            stream.expect_complete()?;
325            stream.expect(&PtxToken::Semicolon)?;
326            Ok(MadRndFtzSatF32 {
327                rnd,
328                ftz,
329                sat,
330                f32,
331                d,
332                a,
333                b,
334                c,
335            })
336        }
337    }
338
339
340    impl PtxParser for MadRndF64 {
341        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
342            stream.expect_string("mad")?;
343            let rnd = Rnd::parse(stream)?;
344            stream.expect_complete()?;
345            stream.expect_string(".f64")?;
346            let f64 = ();
347            stream.expect_complete()?;
348            let d = GeneralOperand::parse(stream)?;
349            stream.expect_complete()?;
350            stream.expect(&PtxToken::Comma)?;
351            let a = GeneralOperand::parse(stream)?;
352            stream.expect_complete()?;
353            stream.expect(&PtxToken::Comma)?;
354            let b = GeneralOperand::parse(stream)?;
355            stream.expect_complete()?;
356            stream.expect(&PtxToken::Comma)?;
357            let c = GeneralOperand::parse(stream)?;
358            stream.expect_complete()?;
359            stream.expect_complete()?;
360            stream.expect(&PtxToken::Semicolon)?;
361            Ok(MadRndF64 {
362                rnd,
363                f64,
364                d,
365                a,
366                b,
367                c,
368            })
369        }
370    }
371
372
373}
374
ptx_parser/parser/instruction/mad.rs

ptx_parser/parser/instruction/
mad.rs
