ptx_parser/parser/instruction/
tensormap_replace.rs

1//! Original PTX specification:
2//!
3//! tensormap.replace.mode.field1{.ss}.b1024.type  [addr], new_val;
4//! tensormap.replace.mode.field2{.ss}.b1024.type  [addr], ord, new_val;
5//! tensormap.replace.mode.field3{.ss}.b1024.type  [addr], new_val;
6//! .mode    = { .tile };
7//! .field1  = { .global_address, .rank };
8//! .field2  = { .box_dim, .global_dim, .global_stride, .element_stride  };
9//! .field3  = { .elemtype,  .interleave_layout, .swizzle_mode, .swizzle_atomicity, .fill_mode };
10//! .ss      = { .global, .shared::cta };
11//! .type    = { .b32, .b64 };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
17use crate::r#type::common::*;
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::tensormap_replace::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Field1 {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try GlobalAddress
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".global_address").is_ok() {
33                    return Ok(Field1::GlobalAddress);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try Rank
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".rank").is_ok() {
42                    return Ok(Field1::Rank);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let span = stream
48                .peek()
49                .map(|(_, s)| s.clone())
50                .unwrap_or(Span { start: 0, end: 0 });
51            let expected = &[".global_address", ".rank"];
52            let found = stream
53                .peek()
54                .map(|(t, _)| format!("{:?}", t))
55                .unwrap_or_else(|_| "<end of input>".to_string());
56            Err(crate::parser::unexpected_value(span, expected, found))
57        }
58    }
59
60    impl PtxParser for Field2 {
61        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
62            // Try ElementStride
63            {
64                let saved_pos = stream.position();
65                if stream.expect_string(".element_stride").is_ok() {
66                    return Ok(Field2::ElementStride);
67                }
68                stream.set_position(saved_pos);
69            }
70            let saved_pos = stream.position();
71            // Try GlobalStride
72            {
73                let saved_pos = stream.position();
74                if stream.expect_string(".global_stride").is_ok() {
75                    return Ok(Field2::GlobalStride);
76                }
77                stream.set_position(saved_pos);
78            }
79            stream.set_position(saved_pos);
80            let saved_pos = stream.position();
81            // Try GlobalDim
82            {
83                let saved_pos = stream.position();
84                if stream.expect_string(".global_dim").is_ok() {
85                    return Ok(Field2::GlobalDim);
86                }
87                stream.set_position(saved_pos);
88            }
89            stream.set_position(saved_pos);
90            let saved_pos = stream.position();
91            // Try BoxDim
92            {
93                let saved_pos = stream.position();
94                if stream.expect_string(".box_dim").is_ok() {
95                    return Ok(Field2::BoxDim);
96                }
97                stream.set_position(saved_pos);
98            }
99            stream.set_position(saved_pos);
100            let span = stream
101                .peek()
102                .map(|(_, s)| s.clone())
103                .unwrap_or(Span { start: 0, end: 0 });
104            let expected = &[
105                ".element_stride",
106                ".global_stride",
107                ".global_dim",
108                ".box_dim",
109            ];
110            let found = stream
111                .peek()
112                .map(|(t, _)| format!("{:?}", t))
113                .unwrap_or_else(|_| "<end of input>".to_string());
114            Err(crate::parser::unexpected_value(span, expected, found))
115        }
116    }
117
118    impl PtxParser for Field3 {
119        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
120            // Try InterleaveLayout
121            {
122                let saved_pos = stream.position();
123                if stream.expect_string(".interleave_layout").is_ok() {
124                    return Ok(Field3::InterleaveLayout);
125                }
126                stream.set_position(saved_pos);
127            }
128            let saved_pos = stream.position();
129            // Try SwizzleAtomicity
130            {
131                let saved_pos = stream.position();
132                if stream.expect_string(".swizzle_atomicity").is_ok() {
133                    return Ok(Field3::SwizzleAtomicity);
134                }
135                stream.set_position(saved_pos);
136            }
137            stream.set_position(saved_pos);
138            let saved_pos = stream.position();
139            // Try SwizzleMode
140            {
141                let saved_pos = stream.position();
142                if stream.expect_string(".swizzle_mode").is_ok() {
143                    return Ok(Field3::SwizzleMode);
144                }
145                stream.set_position(saved_pos);
146            }
147            stream.set_position(saved_pos);
148            let saved_pos = stream.position();
149            // Try FillMode
150            {
151                let saved_pos = stream.position();
152                if stream.expect_string(".fill_mode").is_ok() {
153                    return Ok(Field3::FillMode);
154                }
155                stream.set_position(saved_pos);
156            }
157            stream.set_position(saved_pos);
158            let saved_pos = stream.position();
159            // Try Elemtype
160            {
161                let saved_pos = stream.position();
162                if stream.expect_string(".elemtype").is_ok() {
163                    return Ok(Field3::Elemtype);
164                }
165                stream.set_position(saved_pos);
166            }
167            stream.set_position(saved_pos);
168            let span = stream
169                .peek()
170                .map(|(_, s)| s.clone())
171                .unwrap_or(Span { start: 0, end: 0 });
172            let expected = &[
173                ".interleave_layout",
174                ".swizzle_atomicity",
175                ".swizzle_mode",
176                ".fill_mode",
177                ".elemtype",
178            ];
179            let found = stream
180                .peek()
181                .map(|(t, _)| format!("{:?}", t))
182                .unwrap_or_else(|_| "<end of input>".to_string());
183            Err(crate::parser::unexpected_value(span, expected, found))
184        }
185    }
186
187    impl PtxParser for Mode {
188        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
189            // Try Tile
190            {
191                let saved_pos = stream.position();
192                if stream.expect_string(".tile").is_ok() {
193                    return Ok(Mode::Tile);
194                }
195                stream.set_position(saved_pos);
196            }
197            let span = stream
198                .peek()
199                .map(|(_, s)| s.clone())
200                .unwrap_or(Span { start: 0, end: 0 });
201            let expected = &[".tile"];
202            let found = stream
203                .peek()
204                .map(|(t, _)| format!("{:?}", t))
205                .unwrap_or_else(|_| "<end of input>".to_string());
206            Err(crate::parser::unexpected_value(span, expected, found))
207        }
208    }
209
210    impl PtxParser for Ss {
211        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
212            // Try SharedCta
213            {
214                let saved_pos = stream.position();
215                if stream.expect_string(".shared::cta").is_ok() {
216                    return Ok(Ss::SharedCta);
217                }
218                stream.set_position(saved_pos);
219            }
220            let saved_pos = stream.position();
221            // Try Global
222            {
223                let saved_pos = stream.position();
224                if stream.expect_string(".global").is_ok() {
225                    return Ok(Ss::Global);
226                }
227                stream.set_position(saved_pos);
228            }
229            stream.set_position(saved_pos);
230            let span = stream
231                .peek()
232                .map(|(_, s)| s.clone())
233                .unwrap_or(Span { start: 0, end: 0 });
234            let expected = &[".shared::cta", ".global"];
235            let found = stream
236                .peek()
237                .map(|(t, _)| format!("{:?}", t))
238                .unwrap_or_else(|_| "<end of input>".to_string());
239            Err(crate::parser::unexpected_value(span, expected, found))
240        }
241    }
242
243    impl PtxParser for Type {
244        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
245            // Try B32
246            {
247                let saved_pos = stream.position();
248                if stream.expect_string(".b32").is_ok() {
249                    return Ok(Type::B32);
250                }
251                stream.set_position(saved_pos);
252            }
253            let saved_pos = stream.position();
254            // Try B64
255            {
256                let saved_pos = stream.position();
257                if stream.expect_string(".b64").is_ok() {
258                    return Ok(Type::B64);
259                }
260                stream.set_position(saved_pos);
261            }
262            stream.set_position(saved_pos);
263            let span = stream
264                .peek()
265                .map(|(_, s)| s.clone())
266                .unwrap_or(Span { start: 0, end: 0 });
267            let expected = &[".b32", ".b64"];
268            let found = stream
269                .peek()
270                .map(|(t, _)| format!("{:?}", t))
271                .unwrap_or_else(|_| "<end of input>".to_string());
272            Err(crate::parser::unexpected_value(span, expected, found))
273        }
274    }
275
276    impl PtxParser for TensormapReplaceModeField1SsB1024Type {
277        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
278            stream.expect_string("tensormap")?;
279            stream.expect_string(".replace")?;
280            let replace = ();
281            stream.expect_complete()?;
282            let mode = Mode::parse(stream)?;
283            stream.expect_complete()?;
284            let field1 = Field1::parse(stream)?;
285            stream.expect_complete()?;
286            let saved_pos = stream.position();
287            let ss = match Ss::parse(stream) {
288                Ok(val) => Some(val),
289                Err(_) => {
290                    stream.set_position(saved_pos);
291                    None
292                }
293            };
294            stream.expect_complete()?;
295            stream.expect_string(".b1024")?;
296            let b1024 = ();
297            stream.expect_complete()?;
298            let type_ = Type::parse(stream)?;
299            stream.expect_complete()?;
300            let addr = AddressOperand::parse(stream)?;
301            stream.expect_complete()?;
302            stream.expect(&PtxToken::Comma)?;
303            let new_val = GeneralOperand::parse(stream)?;
304            stream.expect_complete()?;
305            stream.expect_complete()?;
306            stream.expect(&PtxToken::Semicolon)?;
307            Ok(TensormapReplaceModeField1SsB1024Type {
308                replace,
309                mode,
310                field1,
311                ss,
312                b1024,
313                type_,
314                addr,
315                new_val,
316            })
317        }
318    }
319
320    impl PtxParser for TensormapReplaceModeField2SsB1024Type {
321        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
322            stream.expect_string("tensormap")?;
323            stream.expect_string(".replace")?;
324            let replace = ();
325            stream.expect_complete()?;
326            let mode = Mode::parse(stream)?;
327            stream.expect_complete()?;
328            let field2 = Field2::parse(stream)?;
329            stream.expect_complete()?;
330            let saved_pos = stream.position();
331            let ss = match Ss::parse(stream) {
332                Ok(val) => Some(val),
333                Err(_) => {
334                    stream.set_position(saved_pos);
335                    None
336                }
337            };
338            stream.expect_complete()?;
339            stream.expect_string(".b1024")?;
340            let b1024 = ();
341            stream.expect_complete()?;
342            let type_ = Type::parse(stream)?;
343            stream.expect_complete()?;
344            let addr = AddressOperand::parse(stream)?;
345            stream.expect_complete()?;
346            stream.expect(&PtxToken::Comma)?;
347            let ord = GeneralOperand::parse(stream)?;
348            stream.expect_complete()?;
349            stream.expect(&PtxToken::Comma)?;
350            let new_val = GeneralOperand::parse(stream)?;
351            stream.expect_complete()?;
352            stream.expect_complete()?;
353            stream.expect(&PtxToken::Semicolon)?;
354            Ok(TensormapReplaceModeField2SsB1024Type {
355                replace,
356                mode,
357                field2,
358                ss,
359                b1024,
360                type_,
361                addr,
362                ord,
363                new_val,
364            })
365        }
366    }
367
368    impl PtxParser for TensormapReplaceModeField3SsB1024Type {
369        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
370            stream.expect_string("tensormap")?;
371            stream.expect_string(".replace")?;
372            let replace = ();
373            stream.expect_complete()?;
374            let mode = Mode::parse(stream)?;
375            stream.expect_complete()?;
376            let field3 = Field3::parse(stream)?;
377            stream.expect_complete()?;
378            let saved_pos = stream.position();
379            let ss = match Ss::parse(stream) {
380                Ok(val) => Some(val),
381                Err(_) => {
382                    stream.set_position(saved_pos);
383                    None
384                }
385            };
386            stream.expect_complete()?;
387            stream.expect_string(".b1024")?;
388            let b1024 = ();
389            stream.expect_complete()?;
390            let type_ = Type::parse(stream)?;
391            stream.expect_complete()?;
392            let addr = AddressOperand::parse(stream)?;
393            stream.expect_complete()?;
394            stream.expect(&PtxToken::Comma)?;
395            let new_val = GeneralOperand::parse(stream)?;
396            stream.expect_complete()?;
397            stream.expect_complete()?;
398            stream.expect(&PtxToken::Semicolon)?;
399            Ok(TensormapReplaceModeField3SsB1024Type {
400                replace,
401                mode,
402                field3,
403                ss,
404                b1024,
405                type_,
406                addr,
407                new_val,
408            })
409        }
410    }
411}
ptx_parser/parser/instruction/tensormap_replace.rs

ptx_parser/parser/instruction/
tensormap_replace.rs
