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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
47            let expected = &[".u32", ".u64"];
48            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
49            Err(crate::parser::unexpected_value(span, expected, found))
50        }
51    }
52
53    impl PtxParser for Space {
54        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
55            // Try SharedCluster
56            {
57                let saved_pos = stream.position();
58                if stream.expect_string(".shared::cluster").is_ok() {
59                    return Ok(Space::SharedCluster);
60                }
61                stream.set_position(saved_pos);
62            }
63            let saved_pos = stream.position();
64            // Try ParamEntry
65            {
66                let saved_pos = stream.position();
67                if stream.expect_string(".param::entry").is_ok() {
68                    return Ok(Space::ParamEntry);
69                }
70                stream.set_position(saved_pos);
71            }
72            stream.set_position(saved_pos);
73            let saved_pos = stream.position();
74            // Try SharedCta
75            {
76                let saved_pos = stream.position();
77                if stream.expect_string(".shared::cta").is_ok() {
78                    return Ok(Space::SharedCta);
79                }
80                stream.set_position(saved_pos);
81            }
82            stream.set_position(saved_pos);
83            let saved_pos = stream.position();
84            // Try Global
85            {
86                let saved_pos = stream.position();
87                if stream.expect_string(".global").is_ok() {
88                    return Ok(Space::Global);
89                }
90                stream.set_position(saved_pos);
91            }
92            stream.set_position(saved_pos);
93            let saved_pos = stream.position();
94            // Try Shared
95            {
96                let saved_pos = stream.position();
97                if stream.expect_string(".shared").is_ok() {
98                    return Ok(Space::Shared);
99                }
100                stream.set_position(saved_pos);
101            }
102            stream.set_position(saved_pos);
103            let saved_pos = stream.position();
104            // Try Const
105            {
106                let saved_pos = stream.position();
107                if stream.expect_string(".const").is_ok() {
108                    return Ok(Space::Const);
109                }
110                stream.set_position(saved_pos);
111            }
112            stream.set_position(saved_pos);
113            let saved_pos = stream.position();
114            // Try Local
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".local").is_ok() {
118                    return Ok(Space::Local);
119                }
120                stream.set_position(saved_pos);
121            }
122            stream.set_position(saved_pos);
123            let saved_pos = stream.position();
124            // Try Param
125            {
126                let saved_pos = stream.position();
127                if stream.expect_string(".param").is_ok() {
128                    return Ok(Space::Param);
129                }
130                stream.set_position(saved_pos);
131            }
132            stream.set_position(saved_pos);
133            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
134            let expected = &[".shared::cluster", ".param::entry", ".shared::cta", ".global", ".shared", ".const", ".local", ".param"];
135            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
136            Err(crate::parser::unexpected_value(span, expected, found))
137        }
138    }
139
140    impl PtxParser for CvtaSpaceSize {
141        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
142            stream.expect_string("cvta")?;
143            let space = Space::parse(stream)?;
144            stream.expect_complete()?;
145            let size = Size::parse(stream)?;
146            stream.expect_complete()?;
147            let p = GeneralOperand::parse(stream)?;
148            stream.expect_complete()?;
149            stream.expect(&PtxToken::Comma)?;
150            let a = GeneralOperand::parse(stream)?;
151            stream.expect_complete()?;
152            stream.expect_complete()?;
153            stream.expect(&PtxToken::Semicolon)?;
154            Ok(CvtaSpaceSize {
155                space,
156                size,
157                p,
158                a,
159            })
160        }
161    }
162
163
164    impl PtxParser for CvtaToSpaceSize {
165        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
166            stream.expect_string("cvta")?;
167            stream.expect_string(".to")?;
168            let to = ();
169            stream.expect_complete()?;
170            let space = Space::parse(stream)?;
171            stream.expect_complete()?;
172            let size = Size::parse(stream)?;
173            stream.expect_complete()?;
174            let p = GeneralOperand::parse(stream)?;
175            stream.expect_complete()?;
176            stream.expect(&PtxToken::Comma)?;
177            let a = GeneralOperand::parse(stream)?;
178            stream.expect_complete()?;
179            stream.expect_complete()?;
180            stream.expect(&PtxToken::Semicolon)?;
181            Ok(CvtaToSpaceSize {
182                to,
183                space,
184                size,
185                p,
186                a,
187            })
188        }
189    }
190
191
192}
193
ptx_parser/parser/instruction/cvta.rs

ptx_parser/parser/instruction/
cvta.rs
