ptx_parser/parser/instruction/
getctarank.rs

1//! Original PTX specification:
2//!
3//! getctarank{.space}.type d, a;
4//! // Get cta rank from source shared memory address in register a.
5//! getctarank.shared::cluster.type d, a;
6//! // // Get cta rank from shared memory variable.
7//! // getctarank.shared::cluster.type d, var;
8//! // // Get cta rank from shared memory variable+offset.
9//! // getctarank.shared::cluster.type d, var + imm;
10//! // Get cta rank from generic address of shared memory variable in register a.
11//! getctarank.type d, a;
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::getctarank::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
40                .peek()
41                .map(|(_, s)| s.clone())
42                .unwrap_or(Span { start: 0, end: 0 });
43            let expected = &[".shared::cluster"];
44            let found = stream
45                .peek()
46                .map(|(t, _)| format!("{:?}", t))
47                .unwrap_or_else(|_| "<end of input>".to_string());
48            Err(crate::parser::unexpected_value(span, expected, found))
49        }
50    }
51
52    impl PtxParser for Type {
53        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
54            // Try U32
55            {
56                let saved_pos = stream.position();
57                if stream.expect_string(".u32").is_ok() {
58                    return Ok(Type::U32);
59                }
60                stream.set_position(saved_pos);
61            }
62            let saved_pos = stream.position();
63            // Try U64
64            {
65                let saved_pos = stream.position();
66                if stream.expect_string(".u64").is_ok() {
67                    return Ok(Type::U64);
68                }
69                stream.set_position(saved_pos);
70            }
71            stream.set_position(saved_pos);
72            let span = stream
73                .peek()
74                .map(|(_, s)| s.clone())
75                .unwrap_or(Span { start: 0, end: 0 });
76            let expected = &[".u32", ".u64"];
77            let found = stream
78                .peek()
79                .map(|(t, _)| format!("{:?}", t))
80                .unwrap_or_else(|_| "<end of input>".to_string());
81            Err(crate::parser::unexpected_value(span, expected, found))
82        }
83    }
84
85    impl PtxParser for GetctarankSpaceType {
86        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
87            stream.expect_string("getctarank")?;
88            let saved_pos = stream.position();
89            let space = match Space::parse(stream) {
90                Ok(val) => Some(val),
91                Err(_) => {
92                    stream.set_position(saved_pos);
93                    None
94                }
95            };
96            stream.expect_complete()?;
97            let type_ = Type::parse(stream)?;
98            stream.expect_complete()?;
99            let d = GeneralOperand::parse(stream)?;
100            stream.expect_complete()?;
101            stream.expect(&PtxToken::Comma)?;
102            let a = GeneralOperand::parse(stream)?;
103            stream.expect_complete()?;
104            stream.expect_complete()?;
105            stream.expect(&PtxToken::Semicolon)?;
106            Ok(GetctarankSpaceType { space, type_, d, a })
107        }
108    }
109
110    impl PtxParser for GetctarankSharedClusterType {
111        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
112            stream.expect_string("getctarank")?;
113            stream.expect_string(".shared::cluster")?;
114            let shared_cluster = ();
115            stream.expect_complete()?;
116            let type_ = Type::parse(stream)?;
117            stream.expect_complete()?;
118            let d = GeneralOperand::parse(stream)?;
119            stream.expect_complete()?;
120            stream.expect(&PtxToken::Comma)?;
121            let a = GeneralOperand::parse(stream)?;
122            stream.expect_complete()?;
123            stream.expect_complete()?;
124            stream.expect(&PtxToken::Semicolon)?;
125            Ok(GetctarankSharedClusterType {
126                shared_cluster,
127                type_,
128                d,
129                a,
130            })
131        }
132    }
133
134    impl PtxParser for GetctarankType {
135        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
136            stream.expect_string("getctarank")?;
137            let type_ = Type::parse(stream)?;
138            stream.expect_complete()?;
139            let d = GeneralOperand::parse(stream)?;
140            stream.expect_complete()?;
141            stream.expect(&PtxToken::Comma)?;
142            let a = GeneralOperand::parse(stream)?;
143            stream.expect_complete()?;
144            stream.expect_complete()?;
145            stream.expect(&PtxToken::Semicolon)?;
146            Ok(GetctarankType { type_, d, a })
147        }
148    }
149}
ptx_parser/parser/instruction/getctarank.rs

ptx_parser/parser/instruction/
getctarank.rs
