ptx_parser/parser/instruction/
cvta.rs

1//! Original PTX specification:
2//!
3//! // convert const, global, local, or shared address to generic address
4//! cvta.space.size  p, a;        // source address in register a
5//! // cvta.space.size  p, var;      // get generic address of var
6//! // cvta.space.size  p, var+imm;  // generic address of var+offset
7//! // convert generic address to const, global, local, or shared address
8//! cvta.to.space.size  p, a;
9//! .space = { .const, .global, .local, .shared, .shared::cta, .shared::cluster, .param, .param::entry };
10//! .size  = { .u32, .u64 };
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::cvta::section_0::*;
21
22    // ============================================================================
23    // Generated enum parsers
24    // ============================================================================
25
26    impl PtxParser for Size {
27        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
28            // Try U32
29            {
30                let saved_pos = stream.position();
31                if stream.expect_string(".u32").is_ok() {
32                    return Ok(Size::U32);
33                }
34                stream.set_position(saved_pos);
35            }
36            let saved_pos = stream.position();
37            // Try U64
38            {
39                let saved_pos = stream.position();
40                if stream.expect_string(".u64").is_ok() {
41                    return Ok(Size::U64);
42                }
43                stream.set_position(saved_pos);
44            }
45            stream.set_position(saved_pos);
46            let span = stream
47                .peek()
48                .map(|(_, s)| s.clone())
49                .unwrap_or(Span { start: 0, end: 0 });
50            let expected = &[".u32", ".u64"];
51            let found = stream
52                .peek()
53                .map(|(t, _)| format!("{:?}", t))
54                .unwrap_or_else(|_| "<end of input>".to_string());
55            Err(crate::parser::unexpected_value(span, expected, found))
56        }
57    }
58
59    impl PtxParser for Space {
60        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
61            // Try SharedCluster
62            {
63                let saved_pos = stream.position();
64                if stream.expect_string(".shared::cluster").is_ok() {
65                    return Ok(Space::SharedCluster);
66                }
67                stream.set_position(saved_pos);
68            }
69            let saved_pos = stream.position();
70            // Try ParamEntry
71            {
72                let saved_pos = stream.position();
73                if stream.expect_string(".param::entry").is_ok() {
74                    return Ok(Space::ParamEntry);
75                }
76                stream.set_position(saved_pos);
77            }
78            stream.set_position(saved_pos);
79            let saved_pos = stream.position();
80            // Try SharedCta
81            {
82                let saved_pos = stream.position();
83                if stream.expect_string(".shared::cta").is_ok() {
84                    return Ok(Space::SharedCta);
85                }
86                stream.set_position(saved_pos);
87            }
88            stream.set_position(saved_pos);
89            let saved_pos = stream.position();
90            // Try Global
91            {
92                let saved_pos = stream.position();
93                if stream.expect_string(".global").is_ok() {
94                    return Ok(Space::Global);
95                }
96                stream.set_position(saved_pos);
97            }
98            stream.set_position(saved_pos);
99            let saved_pos = stream.position();
100            // Try Shared
101            {
102                let saved_pos = stream.position();
103                if stream.expect_string(".shared").is_ok() {
104                    return Ok(Space::Shared);
105                }
106                stream.set_position(saved_pos);
107            }
108            stream.set_position(saved_pos);
109            let saved_pos = stream.position();
110            // Try Const
111            {
112                let saved_pos = stream.position();
113                if stream.expect_string(".const").is_ok() {
114                    return Ok(Space::Const);
115                }
116                stream.set_position(saved_pos);
117            }
118            stream.set_position(saved_pos);
119            let saved_pos = stream.position();
120            // Try Local
121            {
122                let saved_pos = stream.position();
123                if stream.expect_string(".local").is_ok() {
124                    return Ok(Space::Local);
125                }
126                stream.set_position(saved_pos);
127            }
128            stream.set_position(saved_pos);
129            let saved_pos = stream.position();
130            // Try Param
131            {
132                let saved_pos = stream.position();
133                if stream.expect_string(".param").is_ok() {
134                    return Ok(Space::Param);
135                }
136                stream.set_position(saved_pos);
137            }
138            stream.set_position(saved_pos);
139            let span = stream
140                .peek()
141                .map(|(_, s)| s.clone())
142                .unwrap_or(Span { start: 0, end: 0 });
143            let expected = &[
144                ".shared::cluster",
145                ".param::entry",
146                ".shared::cta",
147                ".global",
148                ".shared",
149                ".const",
150                ".local",
151                ".param",
152            ];
153            let found = stream
154                .peek()
155                .map(|(t, _)| format!("{:?}", t))
156                .unwrap_or_else(|_| "<end of input>".to_string());
157            Err(crate::parser::unexpected_value(span, expected, found))
158        }
159    }
160
161    impl PtxParser for CvtaSpaceSize {
162        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
163            stream.expect_string("cvta")?;
164            let space = Space::parse(stream)?;
165            stream.expect_complete()?;
166            let size = Size::parse(stream)?;
167            stream.expect_complete()?;
168            let p = GeneralOperand::parse(stream)?;
169            stream.expect_complete()?;
170            stream.expect(&PtxToken::Comma)?;
171            let a = GeneralOperand::parse(stream)?;
172            stream.expect_complete()?;
173            stream.expect_complete()?;
174            stream.expect(&PtxToken::Semicolon)?;
175            Ok(CvtaSpaceSize { space, size, p, a })
176        }
177    }
178
179    impl PtxParser for CvtaToSpaceSize {
180        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
181            stream.expect_string("cvta")?;
182            stream.expect_string(".to")?;
183            let to = ();
184            stream.expect_complete()?;
185            let space = Space::parse(stream)?;
186            stream.expect_complete()?;
187            let size = Size::parse(stream)?;
188            stream.expect_complete()?;
189            let p = GeneralOperand::parse(stream)?;
190            stream.expect_complete()?;
191            stream.expect(&PtxToken::Comma)?;
192            let a = GeneralOperand::parse(stream)?;
193            stream.expect_complete()?;
194            stream.expect_complete()?;
195            stream.expect(&PtxToken::Semicolon)?;
196            Ok(CvtaToSpaceSize {
197                to,
198                space,
199                size,
200                p,
201                a,
202            })
203        }
204    }
205}
ptx_parser/parser/instruction/cvta.rs

ptx_parser/parser/instruction/
cvta.rs
