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

ptx_parser/parser/instruction/
mad.rs
