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

ptx_parser/parser/instruction/
ldu.rs
