ptx_parser/parser/instruction/
mov.rs

1//! Original PTX specification:
2//!
3//! mov.type  d, a;
4//! // mov.type  d, sreg;
5//! // mov.type  d, avar;       // get address of variable
6//! // mov.type  d, avar+imm;   // get address of variable with offset
7//! mov.u32   d, fname;      // get address of device function
8//! mov.u64   d, fname;      // get address of device function
9//! mov.u32   d, kernel;     // get address of entry function
10//! mov.u64   d, kernel;     // get address of entry function
11//! .type = { .pred,
12//! .b16, .b32, .b64,
13//! .u16, .u32, .u64,
14//! .s16, .s32, .s64,
15//! .f32, .f64 };
16//! ----------------------------------------------
17//! mov.type  d, a;
18//! .type = { .b16, .b32, .b64, .b128 };
19
20#![allow(unused)]
21
22use crate::lexer::PtxToken;
23use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
24use crate::r#type::common::*;
25
26pub mod section_0 {
27    use super::*;
28    use crate::r#type::instruction::mov::section_0::*;
29
30    // ============================================================================
31    // Generated enum parsers
32    // ============================================================================
33
34    impl PtxParser for Type {
35        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
36            // Try Pred
37            {
38                let saved_pos = stream.position();
39                if stream.expect_string(".pred").is_ok() {
40                    return Ok(Type::Pred);
41                }
42                stream.set_position(saved_pos);
43            }
44            let saved_pos = stream.position();
45            // Try B16
46            {
47                let saved_pos = stream.position();
48                if stream.expect_string(".b16").is_ok() {
49                    return Ok(Type::B16);
50                }
51                stream.set_position(saved_pos);
52            }
53            stream.set_position(saved_pos);
54            let saved_pos = stream.position();
55            // Try B32
56            {
57                let saved_pos = stream.position();
58                if stream.expect_string(".b32").is_ok() {
59                    return Ok(Type::B32);
60                }
61                stream.set_position(saved_pos);
62            }
63            stream.set_position(saved_pos);
64            let saved_pos = stream.position();
65            // Try B64
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".b64").is_ok() {
69                    return Ok(Type::B64);
70                }
71                stream.set_position(saved_pos);
72            }
73            stream.set_position(saved_pos);
74            let saved_pos = stream.position();
75            // Try U16
76            {
77                let saved_pos = stream.position();
78                if stream.expect_string(".u16").is_ok() {
79                    return Ok(Type::U16);
80                }
81                stream.set_position(saved_pos);
82            }
83            stream.set_position(saved_pos);
84            let saved_pos = stream.position();
85            // Try U32
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".u32").is_ok() {
89                    return Ok(Type::U32);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let saved_pos = stream.position();
95            // Try U64
96            {
97                let saved_pos = stream.position();
98                if stream.expect_string(".u64").is_ok() {
99                    return Ok(Type::U64);
100                }
101                stream.set_position(saved_pos);
102            }
103            stream.set_position(saved_pos);
104            let saved_pos = stream.position();
105            // Try S16
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".s16").is_ok() {
109                    return Ok(Type::S16);
110                }
111                stream.set_position(saved_pos);
112            }
113            stream.set_position(saved_pos);
114            let saved_pos = stream.position();
115            // Try S32
116            {
117                let saved_pos = stream.position();
118                if stream.expect_string(".s32").is_ok() {
119                    return Ok(Type::S32);
120                }
121                stream.set_position(saved_pos);
122            }
123            stream.set_position(saved_pos);
124            let saved_pos = stream.position();
125            // Try S64
126            {
127                let saved_pos = stream.position();
128                if stream.expect_string(".s64").is_ok() {
129                    return Ok(Type::S64);
130                }
131                stream.set_position(saved_pos);
132            }
133            stream.set_position(saved_pos);
134            let saved_pos = stream.position();
135            // Try F32
136            {
137                let saved_pos = stream.position();
138                if stream.expect_string(".f32").is_ok() {
139                    return Ok(Type::F32);
140                }
141                stream.set_position(saved_pos);
142            }
143            stream.set_position(saved_pos);
144            let saved_pos = stream.position();
145            // Try F64
146            {
147                let saved_pos = stream.position();
148                if stream.expect_string(".f64").is_ok() {
149                    return Ok(Type::F64);
150                }
151                stream.set_position(saved_pos);
152            }
153            stream.set_position(saved_pos);
154            let span = stream
155                .peek()
156                .map(|(_, s)| s.clone())
157                .unwrap_or(Span { start: 0, end: 0 });
158            let expected = &[
159                ".pred", ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64",
160                ".f32", ".f64",
161            ];
162            let found = stream
163                .peek()
164                .map(|(t, _)| format!("{:?}", t))
165                .unwrap_or_else(|_| "<end of input>".to_string());
166            Err(crate::parser::unexpected_value(span, expected, found))
167        }
168    }
169
170    impl PtxParser for MovType {
171        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
172            stream.expect_string("mov")?;
173            let type_ = Type::parse(stream)?;
174            stream.expect_complete()?;
175            let d = GeneralOperand::parse(stream)?;
176            stream.expect_complete()?;
177            stream.expect(&PtxToken::Comma)?;
178            let a = GeneralOperand::parse(stream)?;
179            stream.expect_complete()?;
180            stream.expect_complete()?;
181            stream.expect(&PtxToken::Semicolon)?;
182            Ok(MovType { type_, d, a })
183        }
184    }
185
186    impl PtxParser for MovU32 {
187        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
188            stream.expect_string("mov")?;
189            stream.expect_string(".u32")?;
190            let u32 = ();
191            stream.expect_complete()?;
192            let d = GeneralOperand::parse(stream)?;
193            stream.expect_complete()?;
194            stream.expect(&PtxToken::Comma)?;
195            let fname = GeneralOperand::parse(stream)?;
196            stream.expect_complete()?;
197            stream.expect_complete()?;
198            stream.expect(&PtxToken::Semicolon)?;
199            Ok(MovU32 { u32, d, fname })
200        }
201    }
202
203    impl PtxParser for MovU64 {
204        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
205            stream.expect_string("mov")?;
206            stream.expect_string(".u64")?;
207            let u64 = ();
208            stream.expect_complete()?;
209            let d = GeneralOperand::parse(stream)?;
210            stream.expect_complete()?;
211            stream.expect(&PtxToken::Comma)?;
212            let fname = GeneralOperand::parse(stream)?;
213            stream.expect_complete()?;
214            stream.expect_complete()?;
215            stream.expect(&PtxToken::Semicolon)?;
216            Ok(MovU64 { u64, d, fname })
217        }
218    }
219
220    impl PtxParser for MovU321 {
221        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
222            stream.expect_string("mov")?;
223            stream.expect_string(".u32")?;
224            let u32 = ();
225            stream.expect_complete()?;
226            let d = GeneralOperand::parse(stream)?;
227            stream.expect_complete()?;
228            stream.expect(&PtxToken::Comma)?;
229            let kernel = GeneralOperand::parse(stream)?;
230            stream.expect_complete()?;
231            stream.expect_complete()?;
232            stream.expect(&PtxToken::Semicolon)?;
233            Ok(MovU321 { u32, d, kernel })
234        }
235    }
236
237    impl PtxParser for MovU641 {
238        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
239            stream.expect_string("mov")?;
240            stream.expect_string(".u64")?;
241            let u64 = ();
242            stream.expect_complete()?;
243            let d = GeneralOperand::parse(stream)?;
244            stream.expect_complete()?;
245            stream.expect(&PtxToken::Comma)?;
246            let kernel = GeneralOperand::parse(stream)?;
247            stream.expect_complete()?;
248            stream.expect_complete()?;
249            stream.expect(&PtxToken::Semicolon)?;
250            Ok(MovU641 { u64, d, kernel })
251        }
252    }
253}
254
255pub mod section_1 {
256    use super::*;
257    use crate::r#type::instruction::mov::section_1::*;
258
259    // ============================================================================
260    // Generated enum parsers
261    // ============================================================================
262
263    impl PtxParser for Type {
264        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
265            // Try B128
266            {
267                let saved_pos = stream.position();
268                if stream.expect_string(".b128").is_ok() {
269                    return Ok(Type::B128);
270                }
271                stream.set_position(saved_pos);
272            }
273            let saved_pos = stream.position();
274            // Try B16
275            {
276                let saved_pos = stream.position();
277                if stream.expect_string(".b16").is_ok() {
278                    return Ok(Type::B16);
279                }
280                stream.set_position(saved_pos);
281            }
282            stream.set_position(saved_pos);
283            let saved_pos = stream.position();
284            // Try B32
285            {
286                let saved_pos = stream.position();
287                if stream.expect_string(".b32").is_ok() {
288                    return Ok(Type::B32);
289                }
290                stream.set_position(saved_pos);
291            }
292            stream.set_position(saved_pos);
293            let saved_pos = stream.position();
294            // Try B64
295            {
296                let saved_pos = stream.position();
297                if stream.expect_string(".b64").is_ok() {
298                    return Ok(Type::B64);
299                }
300                stream.set_position(saved_pos);
301            }
302            stream.set_position(saved_pos);
303            let span = stream
304                .peek()
305                .map(|(_, s)| s.clone())
306                .unwrap_or(Span { start: 0, end: 0 });
307            let expected = &[".b128", ".b16", ".b32", ".b64"];
308            let found = stream
309                .peek()
310                .map(|(t, _)| format!("{:?}", t))
311                .unwrap_or_else(|_| "<end of input>".to_string());
312            Err(crate::parser::unexpected_value(span, expected, found))
313        }
314    }
315
316    impl PtxParser for MovType1 {
317        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
318            stream.expect_string("mov")?;
319            let type_ = Type::parse(stream)?;
320            stream.expect_complete()?;
321            let d = GeneralOperand::parse(stream)?;
322            stream.expect_complete()?;
323            stream.expect(&PtxToken::Comma)?;
324            let a = GeneralOperand::parse(stream)?;
325            stream.expect_complete()?;
326            stream.expect_complete()?;
327            stream.expect(&PtxToken::Semicolon)?;
328            Ok(MovType1 { type_, d, a })
329        }
330    }
331}
ptx_parser/parser/instruction/mov.rs

ptx_parser/parser/instruction/
mov.rs
