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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
48            let expected = &[".global_address", ".rank"];
49            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
50            Err(crate::parser::unexpected_value(span, expected, found))
51        }
52    }
53
54    impl PtxParser for Field2 {
55        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
56            // Try ElementStride
57            {
58                let saved_pos = stream.position();
59                if stream.expect_string(".element_stride").is_ok() {
60                    return Ok(Field2::ElementStride);
61                }
62                stream.set_position(saved_pos);
63            }
64            let saved_pos = stream.position();
65            // Try GlobalStride
66            {
67                let saved_pos = stream.position();
68                if stream.expect_string(".global_stride").is_ok() {
69                    return Ok(Field2::GlobalStride);
70                }
71                stream.set_position(saved_pos);
72            }
73            stream.set_position(saved_pos);
74            let saved_pos = stream.position();
75            // Try GlobalDim
76            {
77                let saved_pos = stream.position();
78                if stream.expect_string(".global_dim").is_ok() {
79                    return Ok(Field2::GlobalDim);
80                }
81                stream.set_position(saved_pos);
82            }
83            stream.set_position(saved_pos);
84            let saved_pos = stream.position();
85            // Try BoxDim
86            {
87                let saved_pos = stream.position();
88                if stream.expect_string(".box_dim").is_ok() {
89                    return Ok(Field2::BoxDim);
90                }
91                stream.set_position(saved_pos);
92            }
93            stream.set_position(saved_pos);
94            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
95            let expected = &[".element_stride", ".global_stride", ".global_dim", ".box_dim"];
96            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
97            Err(crate::parser::unexpected_value(span, expected, found))
98        }
99    }
100
101    impl PtxParser for Field3 {
102        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
103            // Try InterleaveLayout
104            {
105                let saved_pos = stream.position();
106                if stream.expect_string(".interleave_layout").is_ok() {
107                    return Ok(Field3::InterleaveLayout);
108                }
109                stream.set_position(saved_pos);
110            }
111            let saved_pos = stream.position();
112            // Try SwizzleAtomicity
113            {
114                let saved_pos = stream.position();
115                if stream.expect_string(".swizzle_atomicity").is_ok() {
116                    return Ok(Field3::SwizzleAtomicity);
117                }
118                stream.set_position(saved_pos);
119            }
120            stream.set_position(saved_pos);
121            let saved_pos = stream.position();
122            // Try SwizzleMode
123            {
124                let saved_pos = stream.position();
125                if stream.expect_string(".swizzle_mode").is_ok() {
126                    return Ok(Field3::SwizzleMode);
127                }
128                stream.set_position(saved_pos);
129            }
130            stream.set_position(saved_pos);
131            let saved_pos = stream.position();
132            // Try FillMode
133            {
134                let saved_pos = stream.position();
135                if stream.expect_string(".fill_mode").is_ok() {
136                    return Ok(Field3::FillMode);
137                }
138                stream.set_position(saved_pos);
139            }
140            stream.set_position(saved_pos);
141            let saved_pos = stream.position();
142            // Try Elemtype
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".elemtype").is_ok() {
146                    return Ok(Field3::Elemtype);
147                }
148                stream.set_position(saved_pos);
149            }
150            stream.set_position(saved_pos);
151            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
152            let expected = &[".interleave_layout", ".swizzle_atomicity", ".swizzle_mode", ".fill_mode", ".elemtype"];
153            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
154            Err(crate::parser::unexpected_value(span, expected, found))
155        }
156    }
157
158    impl PtxParser for Mode {
159        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
160            // Try Tile
161            {
162                let saved_pos = stream.position();
163                if stream.expect_string(".tile").is_ok() {
164                    return Ok(Mode::Tile);
165                }
166                stream.set_position(saved_pos);
167            }
168            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
169            let expected = &[".tile"];
170            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
171            Err(crate::parser::unexpected_value(span, expected, found))
172        }
173    }
174
175    impl PtxParser for Ss {
176        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
177            // Try SharedCta
178            {
179                let saved_pos = stream.position();
180                if stream.expect_string(".shared::cta").is_ok() {
181                    return Ok(Ss::SharedCta);
182                }
183                stream.set_position(saved_pos);
184            }
185            let saved_pos = stream.position();
186            // Try Global
187            {
188                let saved_pos = stream.position();
189                if stream.expect_string(".global").is_ok() {
190                    return Ok(Ss::Global);
191                }
192                stream.set_position(saved_pos);
193            }
194            stream.set_position(saved_pos);
195            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
196            let expected = &[".shared::cta", ".global"];
197            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
198            Err(crate::parser::unexpected_value(span, expected, found))
199        }
200    }
201
202    impl PtxParser for Type {
203        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
204            // Try B32
205            {
206                let saved_pos = stream.position();
207                if stream.expect_string(".b32").is_ok() {
208                    return Ok(Type::B32);
209                }
210                stream.set_position(saved_pos);
211            }
212            let saved_pos = stream.position();
213            // Try B64
214            {
215                let saved_pos = stream.position();
216                if stream.expect_string(".b64").is_ok() {
217                    return Ok(Type::B64);
218                }
219                stream.set_position(saved_pos);
220            }
221            stream.set_position(saved_pos);
222            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
223            let expected = &[".b32", ".b64"];
224            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
225            Err(crate::parser::unexpected_value(span, expected, found))
226        }
227    }
228
229    impl PtxParser for TensormapReplaceModeField1SsB1024Type {
230        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
231            stream.expect_string("tensormap")?;
232            stream.expect_string(".replace")?;
233            let replace = ();
234            stream.expect_complete()?;
235            let mode = Mode::parse(stream)?;
236            stream.expect_complete()?;
237            let field1 = Field1::parse(stream)?;
238            stream.expect_complete()?;
239            let saved_pos = stream.position();
240            let ss = match Ss::parse(stream) {
241                Ok(val) => Some(val),
242                Err(_) => {
243                    stream.set_position(saved_pos);
244                    None
245                }
246            };
247            stream.expect_complete()?;
248            stream.expect_string(".b1024")?;
249            let b1024 = ();
250            stream.expect_complete()?;
251            let type_ = Type::parse(stream)?;
252            stream.expect_complete()?;
253            let addr = AddressOperand::parse(stream)?;
254            stream.expect_complete()?;
255            stream.expect(&PtxToken::Comma)?;
256            let new_val = GeneralOperand::parse(stream)?;
257            stream.expect_complete()?;
258            stream.expect_complete()?;
259            stream.expect(&PtxToken::Semicolon)?;
260            Ok(TensormapReplaceModeField1SsB1024Type {
261                replace,
262                mode,
263                field1,
264                ss,
265                b1024,
266                type_,
267                addr,
268                new_val,
269            })
270        }
271    }
272
273
274    impl PtxParser for TensormapReplaceModeField2SsB1024Type {
275        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
276            stream.expect_string("tensormap")?;
277            stream.expect_string(".replace")?;
278            let replace = ();
279            stream.expect_complete()?;
280            let mode = Mode::parse(stream)?;
281            stream.expect_complete()?;
282            let field2 = Field2::parse(stream)?;
283            stream.expect_complete()?;
284            let saved_pos = stream.position();
285            let ss = match Ss::parse(stream) {
286                Ok(val) => Some(val),
287                Err(_) => {
288                    stream.set_position(saved_pos);
289                    None
290                }
291            };
292            stream.expect_complete()?;
293            stream.expect_string(".b1024")?;
294            let b1024 = ();
295            stream.expect_complete()?;
296            let type_ = Type::parse(stream)?;
297            stream.expect_complete()?;
298            let addr = AddressOperand::parse(stream)?;
299            stream.expect_complete()?;
300            stream.expect(&PtxToken::Comma)?;
301            let ord = GeneralOperand::parse(stream)?;
302            stream.expect_complete()?;
303            stream.expect(&PtxToken::Comma)?;
304            let new_val = GeneralOperand::parse(stream)?;
305            stream.expect_complete()?;
306            stream.expect_complete()?;
307            stream.expect(&PtxToken::Semicolon)?;
308            Ok(TensormapReplaceModeField2SsB1024Type {
309                replace,
310                mode,
311                field2,
312                ss,
313                b1024,
314                type_,
315                addr,
316                ord,
317                new_val,
318            })
319        }
320    }
321
322
323    impl PtxParser for TensormapReplaceModeField3SsB1024Type {
324        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
325            stream.expect_string("tensormap")?;
326            stream.expect_string(".replace")?;
327            let replace = ();
328            stream.expect_complete()?;
329            let mode = Mode::parse(stream)?;
330            stream.expect_complete()?;
331            let field3 = Field3::parse(stream)?;
332            stream.expect_complete()?;
333            let saved_pos = stream.position();
334            let ss = match Ss::parse(stream) {
335                Ok(val) => Some(val),
336                Err(_) => {
337                    stream.set_position(saved_pos);
338                    None
339                }
340            };
341            stream.expect_complete()?;
342            stream.expect_string(".b1024")?;
343            let b1024 = ();
344            stream.expect_complete()?;
345            let type_ = Type::parse(stream)?;
346            stream.expect_complete()?;
347            let addr = AddressOperand::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(TensormapReplaceModeField3SsB1024Type {
355                replace,
356                mode,
357                field3,
358                ss,
359                b1024,
360                type_,
361                addr,
362                new_val,
363            })
364        }
365    }
366
367
368}
369
ptx_parser/parser/instruction/tensormap_replace.rs

ptx_parser/parser/instruction/
tensormap_replace.rs
