ptx_parser/parser/instruction/
vset.rs

1//! Original PTX specification:
2//!
3//! // 32-bit scalar operation, with optional secondary operation
4//! vset.atype.btype.cmp       d, a{.asel}, b{.bsel};
5//! vset.atype.btype.cmp.op2   d, a{.asel}, b{.bsel}, c;
6//! // 32-bit scalar operation, with optional data merge
7//! vset.atype.btype.cmp  d.dsel, a{.asel}, b{.bsel}, c;
8//! .atype = .btype = { .u32, .s32 };
9//! .cmp   = { .eq, .ne, .lt, .le, .gt, .ge };
10//! .dsel  = .asel  = .bsel  = { .b0, .b1, .b2, .b3, .h0, .h1 };
11//! .op2   = { .add, .min, .max };
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::vset::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Asel {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try B0
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".b0").is_ok() {
33                    return Ok(Asel::B0);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try B1
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".b1").is_ok() {
42                    return Ok(Asel::B1);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let saved_pos = stream.position();
48            // Try B2
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".b2").is_ok() {
52                    return Ok(Asel::B2);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try B3
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".b3").is_ok() {
62                    return Ok(Asel::B3);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let saved_pos = stream.position();
68            // Try H0
69            {
70                let saved_pos = stream.position();
71                if stream.expect_string(".h0").is_ok() {
72                    return Ok(Asel::H0);
73                }
74                stream.set_position(saved_pos);
75            }
76            stream.set_position(saved_pos);
77            let saved_pos = stream.position();
78            // Try H1
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".h1").is_ok() {
82                    return Ok(Asel::H1);
83                }
84                stream.set_position(saved_pos);
85            }
86            stream.set_position(saved_pos);
87            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
88            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
89            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
90            Err(crate::parser::unexpected_value(span, expected, found))
91        }
92    }
93
94    impl PtxParser for Atype {
95        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
96            // Try U32
97            {
98                let saved_pos = stream.position();
99                if stream.expect_string(".u32").is_ok() {
100                    return Ok(Atype::U32);
101                }
102                stream.set_position(saved_pos);
103            }
104            let saved_pos = stream.position();
105            // Try S32
106            {
107                let saved_pos = stream.position();
108                if stream.expect_string(".s32").is_ok() {
109                    return Ok(Atype::S32);
110                }
111                stream.set_position(saved_pos);
112            }
113            stream.set_position(saved_pos);
114            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
115            let expected = &[".u32", ".s32"];
116            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
117            Err(crate::parser::unexpected_value(span, expected, found))
118        }
119    }
120
121    impl PtxParser for Bsel {
122        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
123            // Try B0
124            {
125                let saved_pos = stream.position();
126                if stream.expect_string(".b0").is_ok() {
127                    return Ok(Bsel::B0);
128                }
129                stream.set_position(saved_pos);
130            }
131            let saved_pos = stream.position();
132            // Try B1
133            {
134                let saved_pos = stream.position();
135                if stream.expect_string(".b1").is_ok() {
136                    return Ok(Bsel::B1);
137                }
138                stream.set_position(saved_pos);
139            }
140            stream.set_position(saved_pos);
141            let saved_pos = stream.position();
142            // Try B2
143            {
144                let saved_pos = stream.position();
145                if stream.expect_string(".b2").is_ok() {
146                    return Ok(Bsel::B2);
147                }
148                stream.set_position(saved_pos);
149            }
150            stream.set_position(saved_pos);
151            let saved_pos = stream.position();
152            // Try B3
153            {
154                let saved_pos = stream.position();
155                if stream.expect_string(".b3").is_ok() {
156                    return Ok(Bsel::B3);
157                }
158                stream.set_position(saved_pos);
159            }
160            stream.set_position(saved_pos);
161            let saved_pos = stream.position();
162            // Try H0
163            {
164                let saved_pos = stream.position();
165                if stream.expect_string(".h0").is_ok() {
166                    return Ok(Bsel::H0);
167                }
168                stream.set_position(saved_pos);
169            }
170            stream.set_position(saved_pos);
171            let saved_pos = stream.position();
172            // Try H1
173            {
174                let saved_pos = stream.position();
175                if stream.expect_string(".h1").is_ok() {
176                    return Ok(Bsel::H1);
177                }
178                stream.set_position(saved_pos);
179            }
180            stream.set_position(saved_pos);
181            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
182            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
183            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
184            Err(crate::parser::unexpected_value(span, expected, found))
185        }
186    }
187
188    impl PtxParser for Btype {
189        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
190            // Try U32
191            {
192                let saved_pos = stream.position();
193                if stream.expect_string(".u32").is_ok() {
194                    return Ok(Btype::U32);
195                }
196                stream.set_position(saved_pos);
197            }
198            let saved_pos = stream.position();
199            // Try S32
200            {
201                let saved_pos = stream.position();
202                if stream.expect_string(".s32").is_ok() {
203                    return Ok(Btype::S32);
204                }
205                stream.set_position(saved_pos);
206            }
207            stream.set_position(saved_pos);
208            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
209            let expected = &[".u32", ".s32"];
210            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
211            Err(crate::parser::unexpected_value(span, expected, found))
212        }
213    }
214
215    impl PtxParser for Cmp {
216        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
217            // Try Eq
218            {
219                let saved_pos = stream.position();
220                if stream.expect_string(".eq").is_ok() {
221                    return Ok(Cmp::Eq);
222                }
223                stream.set_position(saved_pos);
224            }
225            let saved_pos = stream.position();
226            // Try Ne
227            {
228                let saved_pos = stream.position();
229                if stream.expect_string(".ne").is_ok() {
230                    return Ok(Cmp::Ne);
231                }
232                stream.set_position(saved_pos);
233            }
234            stream.set_position(saved_pos);
235            let saved_pos = stream.position();
236            // Try Lt
237            {
238                let saved_pos = stream.position();
239                if stream.expect_string(".lt").is_ok() {
240                    return Ok(Cmp::Lt);
241                }
242                stream.set_position(saved_pos);
243            }
244            stream.set_position(saved_pos);
245            let saved_pos = stream.position();
246            // Try Le
247            {
248                let saved_pos = stream.position();
249                if stream.expect_string(".le").is_ok() {
250                    return Ok(Cmp::Le);
251                }
252                stream.set_position(saved_pos);
253            }
254            stream.set_position(saved_pos);
255            let saved_pos = stream.position();
256            // Try Gt
257            {
258                let saved_pos = stream.position();
259                if stream.expect_string(".gt").is_ok() {
260                    return Ok(Cmp::Gt);
261                }
262                stream.set_position(saved_pos);
263            }
264            stream.set_position(saved_pos);
265            let saved_pos = stream.position();
266            // Try Ge
267            {
268                let saved_pos = stream.position();
269                if stream.expect_string(".ge").is_ok() {
270                    return Ok(Cmp::Ge);
271                }
272                stream.set_position(saved_pos);
273            }
274            stream.set_position(saved_pos);
275            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
276            let expected = &[".eq", ".ne", ".lt", ".le", ".gt", ".ge"];
277            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
278            Err(crate::parser::unexpected_value(span, expected, found))
279        }
280    }
281
282    impl PtxParser for Dsel {
283        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
284            // Try B0
285            {
286                let saved_pos = stream.position();
287                if stream.expect_string(".b0").is_ok() {
288                    return Ok(Dsel::B0);
289                }
290                stream.set_position(saved_pos);
291            }
292            let saved_pos = stream.position();
293            // Try B1
294            {
295                let saved_pos = stream.position();
296                if stream.expect_string(".b1").is_ok() {
297                    return Ok(Dsel::B1);
298                }
299                stream.set_position(saved_pos);
300            }
301            stream.set_position(saved_pos);
302            let saved_pos = stream.position();
303            // Try B2
304            {
305                let saved_pos = stream.position();
306                if stream.expect_string(".b2").is_ok() {
307                    return Ok(Dsel::B2);
308                }
309                stream.set_position(saved_pos);
310            }
311            stream.set_position(saved_pos);
312            let saved_pos = stream.position();
313            // Try B3
314            {
315                let saved_pos = stream.position();
316                if stream.expect_string(".b3").is_ok() {
317                    return Ok(Dsel::B3);
318                }
319                stream.set_position(saved_pos);
320            }
321            stream.set_position(saved_pos);
322            let saved_pos = stream.position();
323            // Try H0
324            {
325                let saved_pos = stream.position();
326                if stream.expect_string(".h0").is_ok() {
327                    return Ok(Dsel::H0);
328                }
329                stream.set_position(saved_pos);
330            }
331            stream.set_position(saved_pos);
332            let saved_pos = stream.position();
333            // Try H1
334            {
335                let saved_pos = stream.position();
336                if stream.expect_string(".h1").is_ok() {
337                    return Ok(Dsel::H1);
338                }
339                stream.set_position(saved_pos);
340            }
341            stream.set_position(saved_pos);
342            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
343            let expected = &[".b0", ".b1", ".b2", ".b3", ".h0", ".h1"];
344            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
345            Err(crate::parser::unexpected_value(span, expected, found))
346        }
347    }
348
349    impl PtxParser for Op2 {
350        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
351            // Try Add
352            {
353                let saved_pos = stream.position();
354                if stream.expect_string(".add").is_ok() {
355                    return Ok(Op2::Add);
356                }
357                stream.set_position(saved_pos);
358            }
359            let saved_pos = stream.position();
360            // Try Min
361            {
362                let saved_pos = stream.position();
363                if stream.expect_string(".min").is_ok() {
364                    return Ok(Op2::Min);
365                }
366                stream.set_position(saved_pos);
367            }
368            stream.set_position(saved_pos);
369            let saved_pos = stream.position();
370            // Try Max
371            {
372                let saved_pos = stream.position();
373                if stream.expect_string(".max").is_ok() {
374                    return Ok(Op2::Max);
375                }
376                stream.set_position(saved_pos);
377            }
378            stream.set_position(saved_pos);
379            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
380            let expected = &[".add", ".min", ".max"];
381            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
382            Err(crate::parser::unexpected_value(span, expected, found))
383        }
384    }
385
386    impl PtxParser for VsetAtypeBtypeCmp {
387        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
388            stream.expect_string("vset")?;
389            let atype = Atype::parse(stream)?;
390            stream.expect_complete()?;
391            let btype = Btype::parse(stream)?;
392            stream.expect_complete()?;
393            let cmp = Cmp::parse(stream)?;
394            stream.expect_complete()?;
395            let d = GeneralOperand::parse(stream)?;
396            stream.expect_complete()?;
397            stream.expect(&PtxToken::Comma)?;
398            let a = GeneralOperand::parse(stream)?;
399            let saved_pos = stream.position();
400            let asel = match Asel::parse(stream) {
401                Ok(val) => Some(val),
402                Err(_) => {
403                    stream.set_position(saved_pos);
404                    None
405                }
406            };
407            stream.expect_complete()?;
408            stream.expect(&PtxToken::Comma)?;
409            let b = GeneralOperand::parse(stream)?;
410            let saved_pos = stream.position();
411            let bsel = match Bsel::parse(stream) {
412                Ok(val) => Some(val),
413                Err(_) => {
414                    stream.set_position(saved_pos);
415                    None
416                }
417            };
418            stream.expect_complete()?;
419            stream.expect_complete()?;
420            stream.expect(&PtxToken::Semicolon)?;
421            Ok(VsetAtypeBtypeCmp {
422                atype,
423                btype,
424                cmp,
425                d,
426                a,
427                asel,
428                b,
429                bsel,
430            })
431        }
432    }
433
434
435    impl PtxParser for VsetAtypeBtypeCmpOp2 {
436        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
437            stream.expect_string("vset")?;
438            let atype = Atype::parse(stream)?;
439            stream.expect_complete()?;
440            let btype = Btype::parse(stream)?;
441            stream.expect_complete()?;
442            let cmp = Cmp::parse(stream)?;
443            stream.expect_complete()?;
444            let op2 = Op2::parse(stream)?;
445            stream.expect_complete()?;
446            let d = GeneralOperand::parse(stream)?;
447            stream.expect_complete()?;
448            stream.expect(&PtxToken::Comma)?;
449            let a = GeneralOperand::parse(stream)?;
450            let saved_pos = stream.position();
451            let asel = match Asel::parse(stream) {
452                Ok(val) => Some(val),
453                Err(_) => {
454                    stream.set_position(saved_pos);
455                    None
456                }
457            };
458            stream.expect_complete()?;
459            stream.expect(&PtxToken::Comma)?;
460            let b = GeneralOperand::parse(stream)?;
461            let saved_pos = stream.position();
462            let bsel = match Bsel::parse(stream) {
463                Ok(val) => Some(val),
464                Err(_) => {
465                    stream.set_position(saved_pos);
466                    None
467                }
468            };
469            stream.expect_complete()?;
470            stream.expect(&PtxToken::Comma)?;
471            let c = GeneralOperand::parse(stream)?;
472            stream.expect_complete()?;
473            stream.expect_complete()?;
474            stream.expect(&PtxToken::Semicolon)?;
475            Ok(VsetAtypeBtypeCmpOp2 {
476                atype,
477                btype,
478                cmp,
479                op2,
480                d,
481                a,
482                asel,
483                b,
484                bsel,
485                c,
486            })
487        }
488    }
489
490
491    impl PtxParser for VsetAtypeBtypeCmp1 {
492        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
493            stream.expect_string("vset")?;
494            let atype = Atype::parse(stream)?;
495            stream.expect_complete()?;
496            let btype = Btype::parse(stream)?;
497            stream.expect_complete()?;
498            let cmp = Cmp::parse(stream)?;
499            stream.expect_complete()?;
500            let d = GeneralOperand::parse(stream)?;
501            let dsel = Dsel::parse(stream)?;
502            stream.expect_complete()?;
503            stream.expect(&PtxToken::Comma)?;
504            let a = GeneralOperand::parse(stream)?;
505            let saved_pos = stream.position();
506            let asel = match Asel::parse(stream) {
507                Ok(val) => Some(val),
508                Err(_) => {
509                    stream.set_position(saved_pos);
510                    None
511                }
512            };
513            stream.expect_complete()?;
514            stream.expect(&PtxToken::Comma)?;
515            let b = GeneralOperand::parse(stream)?;
516            let saved_pos = stream.position();
517            let bsel = match Bsel::parse(stream) {
518                Ok(val) => Some(val),
519                Err(_) => {
520                    stream.set_position(saved_pos);
521                    None
522                }
523            };
524            stream.expect_complete()?;
525            stream.expect(&PtxToken::Comma)?;
526            let c = GeneralOperand::parse(stream)?;
527            stream.expect_complete()?;
528            stream.expect_complete()?;
529            stream.expect(&PtxToken::Semicolon)?;
530            Ok(VsetAtypeBtypeCmp1 {
531                atype,
532                btype,
533                cmp,
534                d,
535                dsel,
536                a,
537                asel,
538                b,
539                bsel,
540                c,
541            })
542        }
543    }
544
545
546}
547
ptx_parser/parser/instruction/vset.rs

ptx_parser/parser/instruction/
vset.rs
