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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
155            let expected = &[".pred", ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32", ".f64"];
156            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
157            Err(crate::parser::unexpected_value(span, expected, found))
158        }
159    }
160
161    impl PtxParser for MovType {
162        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
163            stream.expect_string("mov")?;
164            let type_ = Type::parse(stream)?;
165            stream.expect_complete()?;
166            let d = GeneralOperand::parse(stream)?;
167            stream.expect_complete()?;
168            stream.expect(&PtxToken::Comma)?;
169            let a = GeneralOperand::parse(stream)?;
170            stream.expect_complete()?;
171            stream.expect_complete()?;
172            stream.expect(&PtxToken::Semicolon)?;
173            Ok(MovType {
174                type_,
175                d,
176                a,
177            })
178        }
179    }
180
181
182    impl PtxParser for MovU32 {
183        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
184            stream.expect_string("mov")?;
185            stream.expect_string(".u32")?;
186            let u32 = ();
187            stream.expect_complete()?;
188            let d = GeneralOperand::parse(stream)?;
189            stream.expect_complete()?;
190            stream.expect(&PtxToken::Comma)?;
191            let fname = GeneralOperand::parse(stream)?;
192            stream.expect_complete()?;
193            stream.expect_complete()?;
194            stream.expect(&PtxToken::Semicolon)?;
195            Ok(MovU32 {
196                u32,
197                d,
198                fname,
199            })
200        }
201    }
202
203
204    impl PtxParser for MovU64 {
205        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
206            stream.expect_string("mov")?;
207            stream.expect_string(".u64")?;
208            let u64 = ();
209            stream.expect_complete()?;
210            let d = GeneralOperand::parse(stream)?;
211            stream.expect_complete()?;
212            stream.expect(&PtxToken::Comma)?;
213            let fname = GeneralOperand::parse(stream)?;
214            stream.expect_complete()?;
215            stream.expect_complete()?;
216            stream.expect(&PtxToken::Semicolon)?;
217            Ok(MovU64 {
218                u64,
219                d,
220                fname,
221            })
222        }
223    }
224
225
226    impl PtxParser for MovU321 {
227        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
228            stream.expect_string("mov")?;
229            stream.expect_string(".u32")?;
230            let u32 = ();
231            stream.expect_complete()?;
232            let d = GeneralOperand::parse(stream)?;
233            stream.expect_complete()?;
234            stream.expect(&PtxToken::Comma)?;
235            let kernel = GeneralOperand::parse(stream)?;
236            stream.expect_complete()?;
237            stream.expect_complete()?;
238            stream.expect(&PtxToken::Semicolon)?;
239            Ok(MovU321 {
240                u32,
241                d,
242                kernel,
243            })
244        }
245    }
246
247
248    impl PtxParser for MovU641 {
249        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
250            stream.expect_string("mov")?;
251            stream.expect_string(".u64")?;
252            let u64 = ();
253            stream.expect_complete()?;
254            let d = GeneralOperand::parse(stream)?;
255            stream.expect_complete()?;
256            stream.expect(&PtxToken::Comma)?;
257            let kernel = GeneralOperand::parse(stream)?;
258            stream.expect_complete()?;
259            stream.expect_complete()?;
260            stream.expect(&PtxToken::Semicolon)?;
261            Ok(MovU641 {
262                u64,
263                d,
264                kernel,
265            })
266        }
267    }
268
269
270}
271
272pub mod section_1 {
273    use super::*;
274    use crate::r#type::instruction::mov::section_1::*;
275
276    // ============================================================================
277    // Generated enum parsers
278    // ============================================================================
279
280    impl PtxParser for Type {
281        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
282            // Try B128
283            {
284                let saved_pos = stream.position();
285                if stream.expect_string(".b128").is_ok() {
286                    return Ok(Type::B128);
287                }
288                stream.set_position(saved_pos);
289            }
290            let saved_pos = stream.position();
291            // Try B16
292            {
293                let saved_pos = stream.position();
294                if stream.expect_string(".b16").is_ok() {
295                    return Ok(Type::B16);
296                }
297                stream.set_position(saved_pos);
298            }
299            stream.set_position(saved_pos);
300            let saved_pos = stream.position();
301            // Try B32
302            {
303                let saved_pos = stream.position();
304                if stream.expect_string(".b32").is_ok() {
305                    return Ok(Type::B32);
306                }
307                stream.set_position(saved_pos);
308            }
309            stream.set_position(saved_pos);
310            let saved_pos = stream.position();
311            // Try B64
312            {
313                let saved_pos = stream.position();
314                if stream.expect_string(".b64").is_ok() {
315                    return Ok(Type::B64);
316                }
317                stream.set_position(saved_pos);
318            }
319            stream.set_position(saved_pos);
320            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
321            let expected = &[".b128", ".b16", ".b32", ".b64"];
322            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
323            Err(crate::parser::unexpected_value(span, expected, found))
324        }
325    }
326
327    impl PtxParser for MovType1 {
328        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
329            stream.expect_string("mov")?;
330            let type_ = Type::parse(stream)?;
331            stream.expect_complete()?;
332            let d = GeneralOperand::parse(stream)?;
333            stream.expect_complete()?;
334            stream.expect(&PtxToken::Comma)?;
335            let a = GeneralOperand::parse(stream)?;
336            stream.expect_complete()?;
337            stream.expect_complete()?;
338            stream.expect(&PtxToken::Semicolon)?;
339            Ok(MovType1 {
340                type_,
341                d,
342                a,
343            })
344        }
345    }
346
347
348}
349
ptx_parser/parser/instruction/mov.rs

ptx_parser/parser/instruction/
mov.rs
