ptx_parser/parser/instruction/
ldu.rs

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

ptx_parser/parser/instruction/
ldu.rs
