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.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 GetctarankSpaceType {
74        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
75            stream.expect_string("getctarank")?;
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_complete()?;
93            stream.expect(&PtxToken::Semicolon)?;
94            Ok(GetctarankSpaceType {
95                space,
96                type_,
97                d,
98                a,
99            })
100        }
101    }
102
103
104    impl PtxParser for GetctarankSharedClusterType {
105        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
106            stream.expect_string("getctarank")?;
107            stream.expect_string(".shared::cluster")?;
108            let shared_cluster = ();
109            stream.expect_complete()?;
110            let type_ = Type::parse(stream)?;
111            stream.expect_complete()?;
112            let d = GeneralOperand::parse(stream)?;
113            stream.expect_complete()?;
114            stream.expect(&PtxToken::Comma)?;
115            let a = GeneralOperand::parse(stream)?;
116            stream.expect_complete()?;
117            stream.expect_complete()?;
118            stream.expect(&PtxToken::Semicolon)?;
119            Ok(GetctarankSharedClusterType {
120                shared_cluster,
121                type_,
122                d,
123                a,
124            })
125        }
126    }
127
128
129    impl PtxParser for GetctarankType {
130        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
131            stream.expect_string("getctarank")?;
132            let type_ = Type::parse(stream)?;
133            stream.expect_complete()?;
134            let d = GeneralOperand::parse(stream)?;
135            stream.expect_complete()?;
136            stream.expect(&PtxToken::Comma)?;
137            let a = GeneralOperand::parse(stream)?;
138            stream.expect_complete()?;
139            stream.expect_complete()?;
140            stream.expect(&PtxToken::Semicolon)?;
141            Ok(GetctarankType {
142                type_,
143                d,
144                a,
145            })
146        }
147    }
148
149
150}
151
ptx_parser/parser/instruction/getctarank.rs

ptx_parser/parser/instruction/
getctarank.rs
