ptx_parser/parser/instruction/
div.rs

1//! Original PTX specification:
2//!
3//! div.type  d, a, b;
4//! .type = { .u16, .u32, .u64,
5//! .s16, .s32, .s64 };
6//!
7//! div.approx{.ftz}.f32  d, a, b;  // fast, approximate divide
8//! div.full{.ftz}.f32    d, a, b;  // full-range approximate divide
9//! div.rnd{.ftz}.f32     d, a, b;  // IEEE 754 compliant rounding
10//! div.rnd.f64           d, a, b;  // IEEE 754 compliant rounding
11//! .rnd = { .rn, .rz, .rm, .rp };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
17use crate::r#type::common::*;
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::div::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Rnd {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try Rn
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".rn").is_ok() {
33                    return Ok(Rnd::Rn);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try Rz
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".rz").is_ok() {
42                    return Ok(Rnd::Rz);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let saved_pos = stream.position();
48            // Try Rm
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".rm").is_ok() {
52                    return Ok(Rnd::Rm);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try Rp
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".rp").is_ok() {
62                    return Ok(Rnd::Rp);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let span = stream
68                .peek()
69                .map(|(_, s)| s.clone())
70                .unwrap_or(Span { start: 0, end: 0 });
71            let expected = &[".rn", ".rz", ".rm", ".rp"];
72            let found = stream
73                .peek()
74                .map(|(t, _)| format!("{:?}", t))
75                .unwrap_or_else(|_| "<end of input>".to_string());
76            Err(crate::parser::unexpected_value(span, expected, found))
77        }
78    }
79
80    impl PtxParser for Type {
81        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
82            // Try U16
83            {
84                let saved_pos = stream.position();
85                if stream.expect_string(".u16").is_ok() {
86                    return Ok(Type::U16);
87                }
88                stream.set_position(saved_pos);
89            }
90            let saved_pos = stream.position();
91            // Try U32
92            {
93                let saved_pos = stream.position();
94                if stream.expect_string(".u32").is_ok() {
95                    return Ok(Type::U32);
96                }
97                stream.set_position(saved_pos);
98            }
99            stream.set_position(saved_pos);
100            let saved_pos = stream.position();
101            // Try U64
102            {
103                let saved_pos = stream.position();
104                if stream.expect_string(".u64").is_ok() {
105                    return Ok(Type::U64);
106                }
107                stream.set_position(saved_pos);
108            }
109            stream.set_position(saved_pos);
110            let saved_pos = stream.position();
111            // Try S16
112            {
113                let saved_pos = stream.position();
114                if stream.expect_string(".s16").is_ok() {
115                    return Ok(Type::S16);
116                }
117                stream.set_position(saved_pos);
118            }
119            stream.set_position(saved_pos);
120            let saved_pos = stream.position();
121            // Try S32
122            {
123                let saved_pos = stream.position();
124                if stream.expect_string(".s32").is_ok() {
125                    return Ok(Type::S32);
126                }
127                stream.set_position(saved_pos);
128            }
129            stream.set_position(saved_pos);
130            let saved_pos = stream.position();
131            // Try S64
132            {
133                let saved_pos = stream.position();
134                if stream.expect_string(".s64").is_ok() {
135                    return Ok(Type::S64);
136                }
137                stream.set_position(saved_pos);
138            }
139            stream.set_position(saved_pos);
140            let span = stream
141                .peek()
142                .map(|(_, s)| s.clone())
143                .unwrap_or(Span { start: 0, end: 0 });
144            let expected = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
145            let found = stream
146                .peek()
147                .map(|(t, _)| format!("{:?}", t))
148                .unwrap_or_else(|_| "<end of input>".to_string());
149            Err(crate::parser::unexpected_value(span, expected, found))
150        }
151    }
152
153    impl PtxParser for DivType {
154        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
155            stream.expect_string("div")?;
156            let type_ = Type::parse(stream)?;
157            stream.expect_complete()?;
158            let d = GeneralOperand::parse(stream)?;
159            stream.expect_complete()?;
160            stream.expect(&PtxToken::Comma)?;
161            let a = GeneralOperand::parse(stream)?;
162            stream.expect_complete()?;
163            stream.expect(&PtxToken::Comma)?;
164            let b = GeneralOperand::parse(stream)?;
165            stream.expect_complete()?;
166            stream.expect_complete()?;
167            stream.expect(&PtxToken::Semicolon)?;
168            Ok(DivType { type_, d, a, b })
169        }
170    }
171
172    impl PtxParser for DivApproxFtzF32 {
173        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
174            stream.expect_string("div")?;
175            stream.expect_string(".approx")?;
176            let approx = ();
177            stream.expect_complete()?;
178            let saved_pos = stream.position();
179            let ftz = stream.expect_string(".ftz").is_ok();
180            if !ftz {
181                stream.set_position(saved_pos);
182            }
183            stream.expect_complete()?;
184            stream.expect_string(".f32")?;
185            let f32 = ();
186            stream.expect_complete()?;
187            let d = GeneralOperand::parse(stream)?;
188            stream.expect_complete()?;
189            stream.expect(&PtxToken::Comma)?;
190            let a = GeneralOperand::parse(stream)?;
191            stream.expect_complete()?;
192            stream.expect(&PtxToken::Comma)?;
193            let b = GeneralOperand::parse(stream)?;
194            stream.expect_complete()?;
195            stream.expect_complete()?;
196            stream.expect(&PtxToken::Semicolon)?;
197            Ok(DivApproxFtzF32 {
198                approx,
199                ftz,
200                f32,
201                d,
202                a,
203                b,
204            })
205        }
206    }
207
208    impl PtxParser for DivFullFtzF32 {
209        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
210            stream.expect_string("div")?;
211            stream.expect_string(".full")?;
212            let full = ();
213            stream.expect_complete()?;
214            let saved_pos = stream.position();
215            let ftz = stream.expect_string(".ftz").is_ok();
216            if !ftz {
217                stream.set_position(saved_pos);
218            }
219            stream.expect_complete()?;
220            stream.expect_string(".f32")?;
221            let f32 = ();
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_complete()?;
232            stream.expect(&PtxToken::Semicolon)?;
233            Ok(DivFullFtzF32 {
234                full,
235                ftz,
236                f32,
237                d,
238                a,
239                b,
240            })
241        }
242    }
243
244    impl PtxParser for DivRndFtzF32 {
245        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
246            stream.expect_string("div")?;
247            let rnd = Rnd::parse(stream)?;
248            stream.expect_complete()?;
249            let saved_pos = stream.position();
250            let ftz = stream.expect_string(".ftz").is_ok();
251            if !ftz {
252                stream.set_position(saved_pos);
253            }
254            stream.expect_complete()?;
255            stream.expect_string(".f32")?;
256            let f32 = ();
257            stream.expect_complete()?;
258            let d = GeneralOperand::parse(stream)?;
259            stream.expect_complete()?;
260            stream.expect(&PtxToken::Comma)?;
261            let a = GeneralOperand::parse(stream)?;
262            stream.expect_complete()?;
263            stream.expect(&PtxToken::Comma)?;
264            let b = GeneralOperand::parse(stream)?;
265            stream.expect_complete()?;
266            stream.expect_complete()?;
267            stream.expect(&PtxToken::Semicolon)?;
268            Ok(DivRndFtzF32 {
269                rnd,
270                ftz,
271                f32,
272                d,
273                a,
274                b,
275            })
276        }
277    }
278
279    impl PtxParser for DivRndF64 {
280        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
281            stream.expect_string("div")?;
282            let rnd = Rnd::parse(stream)?;
283            stream.expect_complete()?;
284            stream.expect_string(".f64")?;
285            let f64 = ();
286            stream.expect_complete()?;
287            let d = GeneralOperand::parse(stream)?;
288            stream.expect_complete()?;
289            stream.expect(&PtxToken::Comma)?;
290            let a = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Comma)?;
293            let b = GeneralOperand::parse(stream)?;
294            stream.expect_complete()?;
295            stream.expect_complete()?;
296            stream.expect(&PtxToken::Semicolon)?;
297            Ok(DivRndF64 { rnd, f64, d, a, b })
298        }
299    }
300}
ptx_parser/parser/instruction/div.rs

ptx_parser/parser/instruction/
div.rs
