ptx_parser/parser/instruction/
mapa.rs

1//! Original PTX specification:
2//!
3//! mapa{.space}.type          d, a, b;
4//! // Maps shared memory address in register a into CTA b.
5//! // mapa.shared::cluster.type  d, a, b;
6//! // Maps shared memory variable into CTA b.
7//! // mapa.shared::cluster.type  d, sh, b;
8//! // Maps shared memory variable into CTA b.
9//! // mapa.shared::cluster.type  d, sh + imm, b;
10//! // Maps generic address in register a into CTA b.
11//! // mapa.type                  d, a, b;
12//! .space = { .shared::cluster };
13//! .type  = { .u32, .u64 };
14
15#![allow(unused)]
16
17use crate::lexer::PtxToken;
18use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
19use crate::r#type::common::*;
20
21pub mod section_0 {
22    use super::*;
23    use crate::r#type::instruction::mapa::section_0::*;
24
25    // ============================================================================
26    // Generated enum parsers
27    // ============================================================================
28
29    impl PtxParser for Space {
30        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
31            // Try SharedCluster
32            {
33                let saved_pos = stream.position();
34                if stream.expect_string(".shared::cluster").is_ok() {
35                    return Ok(Space::SharedCluster);
36                }
37                stream.set_position(saved_pos);
38            }
39            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
40            let expected = &[".shared::cluster"];
41            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
42            Err(crate::parser::unexpected_value(span, expected, found))
43        }
44    }
45
46    impl PtxParser for Type {
47        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
48            // Try U32
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".u32").is_ok() {
52                    return Ok(Type::U32);
53                }
54                stream.set_position(saved_pos);
55            }
56            let saved_pos = stream.position();
57            // Try U64
58            {
59                let saved_pos = stream.position();
60                if stream.expect_string(".u64").is_ok() {
61                    return Ok(Type::U64);
62                }
63                stream.set_position(saved_pos);
64            }
65            stream.set_position(saved_pos);
66            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
67            let expected = &[".u32", ".u64"];
68            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
69            Err(crate::parser::unexpected_value(span, expected, found))
70        }
71    }
72
73    impl PtxParser for MapaSpaceType {
74        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
75            stream.expect_string("mapa")?;
76            let saved_pos = stream.position();
77            let space = match Space::parse(stream) {
78                Ok(val) => Some(val),
79                Err(_) => {
80                    stream.set_position(saved_pos);
81                    None
82                }
83            };
84            stream.expect_complete()?;
85            let type_ = Type::parse(stream)?;
86            stream.expect_complete()?;
87            let d = GeneralOperand::parse(stream)?;
88            stream.expect_complete()?;
89            stream.expect(&PtxToken::Comma)?;
90            let a = GeneralOperand::parse(stream)?;
91            stream.expect_complete()?;
92            stream.expect(&PtxToken::Comma)?;
93            let b = GeneralOperand::parse(stream)?;
94            stream.expect_complete()?;
95            stream.expect_complete()?;
96            stream.expect(&PtxToken::Semicolon)?;
97            Ok(MapaSpaceType {
98                space,
99                type_,
100                d,
101                a,
102                b,
103            })
104        }
105    }
106
107
108}
109