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

ptx_parser/parser/instruction/
redux_sync.rs
