ptx_parser/parser/instruction/
redux_sync.rs

1//! Original PTX specification:
2//!
3//! redux.sync.op.type dst, src, membermask;
4//! .op   = {.add, .min, .max};
5//! .type = {.u32, .s32};
6//! ----------------------------------------------------
7//! // Alternate floating point type:
8//! redux.sync.op.b32 dst, src, membermask;
9//! .op   = {.and, .or, .xor};
10//! ----------------------------------------------------
11//! // Alternate floating point type:
12//! redux.sync.op{.abs}{.NaN}.f32 dst, src, membermask;
13//! .op   = { .min, .max };
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::redux_sync::section_0::*;
24
25    // ============================================================================
26    // Generated enum parsers
27    // ============================================================================
28
29    impl PtxParser for Op {
30        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
31            // Try Add
32            {
33                let saved_pos = stream.position();
34                if stream.expect_string(".add").is_ok() {
35                    return Ok(Op::Add);
36                }
37                stream.set_position(saved_pos);
38            }
39            let saved_pos = stream.position();
40            // Try Min
41            {
42                let saved_pos = stream.position();
43                if stream.expect_string(".min").is_ok() {
44                    return Ok(Op::Min);
45                }
46                stream.set_position(saved_pos);
47            }
48            stream.set_position(saved_pos);
49            let saved_pos = stream.position();
50            // Try Max
51            {
52                let saved_pos = stream.position();
53                if stream.expect_string(".max").is_ok() {
54                    return Ok(Op::Max);
55                }
56                stream.set_position(saved_pos);
57            }
58            stream.set_position(saved_pos);
59            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
60            let expected = &[".add", ".min", ".max"];
61            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
62            Err(crate::parser::unexpected_value(span, expected, found))
63        }
64    }
65
66    impl PtxParser for Type {
67        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
68            // Try U32
69            {
70                let saved_pos = stream.position();
71                if stream.expect_string(".u32").is_ok() {
72                    return Ok(Type::U32);
73                }
74                stream.set_position(saved_pos);
75            }
76            let saved_pos = stream.position();
77            // Try S32
78            {
79                let saved_pos = stream.position();
80                if stream.expect_string(".s32").is_ok() {
81                    return Ok(Type::S32);
82                }
83                stream.set_position(saved_pos);
84            }
85            stream.set_position(saved_pos);
86            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
87            let expected = &[".u32", ".s32"];
88            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
89            Err(crate::parser::unexpected_value(span, expected, found))
90        }
91    }
92
93    impl PtxParser for ReduxSyncOpType {
94        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
95            stream.expect_string("redux")?;
96            stream.expect_string(".sync")?;
97            let sync = ();
98            stream.expect_complete()?;
99            let op = Op::parse(stream)?;
100            stream.expect_complete()?;
101            let type_ = Type::parse(stream)?;
102            stream.expect_complete()?;
103            let dst = GeneralOperand::parse(stream)?;
104            stream.expect_complete()?;
105            stream.expect(&PtxToken::Comma)?;
106            let src = GeneralOperand::parse(stream)?;
107            stream.expect_complete()?;
108            stream.expect(&PtxToken::Comma)?;
109            let membermask = GeneralOperand::parse(stream)?;
110            stream.expect_complete()?;
111            stream.expect_complete()?;
112            stream.expect(&PtxToken::Semicolon)?;
113            Ok(ReduxSyncOpType {
114                sync,
115                op,
116                type_,
117                dst,
118                src,
119                membermask,
120            })
121        }
122    }
123
124
125}
126
127pub mod section_1 {
128    use super::*;
129    use crate::r#type::instruction::redux_sync::section_1::*;
130
131    // ============================================================================
132    // Generated enum parsers
133    // ============================================================================
134
135    impl PtxParser for Op {
136        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
137            // Try And
138            {
139                let saved_pos = stream.position();
140                if stream.expect_string(".and").is_ok() {
141                    return Ok(Op::And);
142                }
143                stream.set_position(saved_pos);
144            }
145            let saved_pos = stream.position();
146            // Try Xor
147            {
148                let saved_pos = stream.position();
149                if stream.expect_string(".xor").is_ok() {
150                    return Ok(Op::Xor);
151                }
152                stream.set_position(saved_pos);
153            }
154            stream.set_position(saved_pos);
155            let saved_pos = stream.position();
156            // Try Or
157            {
158                let saved_pos = stream.position();
159                if stream.expect_string(".or").is_ok() {
160                    return Ok(Op::Or);
161                }
162                stream.set_position(saved_pos);
163            }
164            stream.set_position(saved_pos);
165            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
166            let expected = &[".and", ".xor", ".or"];
167            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
168            Err(crate::parser::unexpected_value(span, expected, found))
169        }
170    }
171
172    impl PtxParser for ReduxSyncOpB32 {
173        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
174            stream.expect_string("redux")?;
175            stream.expect_string(".sync")?;
176            let sync = ();
177            stream.expect_complete()?;
178            let op = Op::parse(stream)?;
179            stream.expect_complete()?;
180            stream.expect_string(".b32")?;
181            let b32 = ();
182            stream.expect_complete()?;
183            let dst = GeneralOperand::parse(stream)?;
184            stream.expect_complete()?;
185            stream.expect(&PtxToken::Comma)?;
186            let src = GeneralOperand::parse(stream)?;
187            stream.expect_complete()?;
188            stream.expect(&PtxToken::Comma)?;
189            let membermask = GeneralOperand::parse(stream)?;
190            stream.expect_complete()?;
191            stream.expect_complete()?;
192            stream.expect(&PtxToken::Semicolon)?;
193            Ok(ReduxSyncOpB32 {
194                sync,
195                op,
196                b32,
197                dst,
198                src,
199                membermask,
200            })
201        }
202    }
203
204
205}
206
207pub mod section_2 {
208    use super::*;
209    use crate::r#type::instruction::redux_sync::section_2::*;
210
211    // ============================================================================
212    // Generated enum parsers
213    // ============================================================================
214
215    impl PtxParser for Op {
216        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
217            // Try Min
218            {
219                let saved_pos = stream.position();
220                if stream.expect_string(".min").is_ok() {
221                    return Ok(Op::Min);
222                }
223                stream.set_position(saved_pos);
224            }
225            let saved_pos = stream.position();
226            // Try Max
227            {
228                let saved_pos = stream.position();
229                if stream.expect_string(".max").is_ok() {
230                    return Ok(Op::Max);
231                }
232                stream.set_position(saved_pos);
233            }
234            stream.set_position(saved_pos);
235            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
236            let expected = &[".min", ".max"];
237            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
238            Err(crate::parser::unexpected_value(span, expected, found))
239        }
240    }
241
242    impl PtxParser for ReduxSyncOpAbsNanF32 {
243        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
244            stream.expect_string("redux")?;
245            stream.expect_string(".sync")?;
246            let sync = ();
247            stream.expect_complete()?;
248            let op = Op::parse(stream)?;
249            stream.expect_complete()?;
250            let saved_pos = stream.position();
251            let abs = stream.expect_string(".abs").is_ok();
252            if !abs {
253                stream.set_position(saved_pos);
254            }
255            stream.expect_complete()?;
256            let saved_pos = stream.position();
257            let nan = stream.expect_string(".NaN").is_ok();
258            if !nan {
259                stream.set_position(saved_pos);
260            }
261            stream.expect_complete()?;
262            stream.expect_string(".f32")?;
263            let f32 = ();
264            stream.expect_complete()?;
265            let dst = GeneralOperand::parse(stream)?;
266            stream.expect_complete()?;
267            stream.expect(&PtxToken::Comma)?;
268            let src = GeneralOperand::parse(stream)?;
269            stream.expect_complete()?;
270            stream.expect(&PtxToken::Comma)?;
271            let membermask = GeneralOperand::parse(stream)?;
272            stream.expect_complete()?;
273            stream.expect_complete()?;
274            stream.expect(&PtxToken::Semicolon)?;
275            Ok(ReduxSyncOpAbsNanF32 {
276                sync,
277                op,
278                abs,
279                nan,
280                f32,
281                dst,
282                src,
283                membermask,
284            })
285        }
286    }
287
288
289}
290
ptx_parser/parser/instruction/redux_sync.rs

ptx_parser/parser/instruction/
redux_sync.rs
