ptx_parser/parser/instruction/
bar.rs

1//! Original PTX specification:
2//!
3//! barrier{.cta}.sync{.aligned}      a{, b};
4//! barrier{.cta}.arrive{.aligned}    a, b;
5//! barrier{.cta}.red.popc{.aligned}.u32  d, a{, b}, {!}c;
6//! barrier{.cta}.red.op{.aligned}.pred   p, a{, b}, {!}c;
7//! bar{.cta}.sync      a{, b};
8//! bar{.cta}.arrive    a, b;
9//! bar{.cta}.red.popc.u32  d, a{, b}, {!}c;
10//! bar{.cta}.red.op.pred   p, a{, b}, {!}c;
11//! .op = { .and, .or };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
17use crate::r#type::common::*;
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::bar::section_0::*;
22
23    // ============================================================================
24    // Generated enum parsers
25    // ============================================================================
26
27    impl PtxParser for Op {
28        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
29            // Try And
30            {
31                let saved_pos = stream.position();
32                if stream.expect_string(".and").is_ok() {
33                    return Ok(Op::And);
34                }
35                stream.set_position(saved_pos);
36            }
37            let saved_pos = stream.position();
38            // Try Or
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".or").is_ok() {
42                    return Ok(Op::Or);
43                }
44                stream.set_position(saved_pos);
45            }
46            stream.set_position(saved_pos);
47            let span = stream
48                .peek()
49                .map(|(_, s)| s.clone())
50                .unwrap_or(Span { start: 0, end: 0 });
51            let expected = &[".and", ".or"];
52            let found = stream
53                .peek()
54                .map(|(t, _)| format!("{:?}", t))
55                .unwrap_or_else(|_| "<end of input>".to_string());
56            Err(crate::parser::unexpected_value(span, expected, found))
57        }
58    }
59
60    impl PtxParser for BarrierCtaSyncAligned {
61        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
62            stream.expect_string("barrier")?;
63            let saved_pos = stream.position();
64            let cta = stream.expect_string(".cta").is_ok();
65            if !cta {
66                stream.set_position(saved_pos);
67            }
68            stream.expect_complete()?;
69            stream.expect_string(".sync")?;
70            let sync = ();
71            stream.expect_complete()?;
72            let saved_pos = stream.position();
73            let aligned = stream.expect_string(".aligned").is_ok();
74            if !aligned {
75                stream.set_position(saved_pos);
76            }
77            stream.expect_complete()?;
78            let a = GeneralOperand::parse(stream)?;
79            stream.expect_complete()?;
80            let saved_pos = stream.position();
81            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
82            if !has_comma {
83                stream.set_position(saved_pos);
84            }
85            let saved_pos = stream.position();
86            let b = match GeneralOperand::parse(stream) {
87                Ok(val) => Some(val),
88                Err(_) => {
89                    stream.set_position(saved_pos);
90                    None
91                }
92            };
93            stream.expect_complete()?;
94            stream.expect_complete()?;
95            stream.expect(&PtxToken::Semicolon)?;
96            Ok(BarrierCtaSyncAligned {
97                cta,
98                sync,
99                aligned,
100                a,
101                b,
102            })
103        }
104    }
105
106    impl PtxParser for BarrierCtaArriveAligned {
107        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
108            stream.expect_string("barrier")?;
109            let saved_pos = stream.position();
110            let cta = stream.expect_string(".cta").is_ok();
111            if !cta {
112                stream.set_position(saved_pos);
113            }
114            stream.expect_complete()?;
115            stream.expect_string(".arrive")?;
116            let arrive = ();
117            stream.expect_complete()?;
118            let saved_pos = stream.position();
119            let aligned = stream.expect_string(".aligned").is_ok();
120            if !aligned {
121                stream.set_position(saved_pos);
122            }
123            stream.expect_complete()?;
124            let a = GeneralOperand::parse(stream)?;
125            stream.expect_complete()?;
126            stream.expect(&PtxToken::Comma)?;
127            let b = GeneralOperand::parse(stream)?;
128            stream.expect_complete()?;
129            stream.expect_complete()?;
130            stream.expect(&PtxToken::Semicolon)?;
131            Ok(BarrierCtaArriveAligned {
132                cta,
133                arrive,
134                aligned,
135                a,
136                b,
137            })
138        }
139    }
140
141    impl PtxParser for BarrierCtaRedPopcAlignedU32 {
142        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
143            stream.expect_string("barrier")?;
144            let saved_pos = stream.position();
145            let cta = stream.expect_string(".cta").is_ok();
146            if !cta {
147                stream.set_position(saved_pos);
148            }
149            stream.expect_complete()?;
150            stream.expect_string(".red")?;
151            let red = ();
152            stream.expect_complete()?;
153            stream.expect_string(".popc")?;
154            let popc = ();
155            stream.expect_complete()?;
156            let saved_pos = stream.position();
157            let aligned = stream.expect_string(".aligned").is_ok();
158            if !aligned {
159                stream.set_position(saved_pos);
160            }
161            stream.expect_complete()?;
162            stream.expect_string(".u32")?;
163            let u32 = ();
164            stream.expect_complete()?;
165            let d = GeneralOperand::parse(stream)?;
166            stream.expect_complete()?;
167            stream.expect(&PtxToken::Comma)?;
168            let a = GeneralOperand::parse(stream)?;
169            stream.expect_complete()?;
170            let saved_pos = stream.position();
171            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
172            if !has_comma {
173                stream.set_position(saved_pos);
174            }
175            let saved_pos = stream.position();
176            let b = match GeneralOperand::parse(stream) {
177                Ok(val) => Some(val),
178                Err(_) => {
179                    stream.set_position(saved_pos);
180                    None
181                }
182            };
183            stream.expect_complete()?;
184            stream.expect(&PtxToken::Comma)?;
185            let c_op = stream
186                .consume_if(|t| matches!(t, PtxToken::Exclaim))
187                .is_some();
188            let c = GeneralOperand::parse(stream)?;
189            stream.expect_complete()?;
190            stream.expect_complete()?;
191            stream.expect(&PtxToken::Semicolon)?;
192            Ok(BarrierCtaRedPopcAlignedU32 {
193                cta,
194                red,
195                popc,
196                aligned,
197                u32,
198                d,
199                a,
200                b,
201                c_op,
202                c,
203            })
204        }
205    }
206
207    impl PtxParser for BarrierCtaRedOpAlignedPred {
208        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
209            stream.expect_string("barrier")?;
210            let saved_pos = stream.position();
211            let cta = stream.expect_string(".cta").is_ok();
212            if !cta {
213                stream.set_position(saved_pos);
214            }
215            stream.expect_complete()?;
216            stream.expect_string(".red")?;
217            let red = ();
218            stream.expect_complete()?;
219            let op = Op::parse(stream)?;
220            stream.expect_complete()?;
221            let saved_pos = stream.position();
222            let aligned = stream.expect_string(".aligned").is_ok();
223            if !aligned {
224                stream.set_position(saved_pos);
225            }
226            stream.expect_complete()?;
227            stream.expect_string(".pred")?;
228            let pred = ();
229            stream.expect_complete()?;
230            let p = GeneralOperand::parse(stream)?;
231            stream.expect_complete()?;
232            stream.expect(&PtxToken::Comma)?;
233            let a = GeneralOperand::parse(stream)?;
234            stream.expect_complete()?;
235            let saved_pos = stream.position();
236            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
237            if !has_comma {
238                stream.set_position(saved_pos);
239            }
240            let saved_pos = stream.position();
241            let b = match GeneralOperand::parse(stream) {
242                Ok(val) => Some(val),
243                Err(_) => {
244                    stream.set_position(saved_pos);
245                    None
246                }
247            };
248            stream.expect_complete()?;
249            stream.expect(&PtxToken::Comma)?;
250            let c_op = stream
251                .consume_if(|t| matches!(t, PtxToken::Exclaim))
252                .is_some();
253            let c = GeneralOperand::parse(stream)?;
254            stream.expect_complete()?;
255            stream.expect_complete()?;
256            stream.expect(&PtxToken::Semicolon)?;
257            Ok(BarrierCtaRedOpAlignedPred {
258                cta,
259                red,
260                op,
261                aligned,
262                pred,
263                p,
264                a,
265                b,
266                c_op,
267                c,
268            })
269        }
270    }
271
272    impl PtxParser for BarCtaSync {
273        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
274            stream.expect_string("bar")?;
275            let saved_pos = stream.position();
276            let cta = stream.expect_string(".cta").is_ok();
277            if !cta {
278                stream.set_position(saved_pos);
279            }
280            stream.expect_complete()?;
281            stream.expect_string(".sync")?;
282            let sync = ();
283            stream.expect_complete()?;
284            let a = GeneralOperand::parse(stream)?;
285            stream.expect_complete()?;
286            let saved_pos = stream.position();
287            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
288            if !has_comma {
289                stream.set_position(saved_pos);
290            }
291            let saved_pos = stream.position();
292            let b = match GeneralOperand::parse(stream) {
293                Ok(val) => Some(val),
294                Err(_) => {
295                    stream.set_position(saved_pos);
296                    None
297                }
298            };
299            stream.expect_complete()?;
300            stream.expect_complete()?;
301            stream.expect(&PtxToken::Semicolon)?;
302            Ok(BarCtaSync { cta, sync, a, b })
303        }
304    }
305
306    impl PtxParser for BarCtaArrive {
307        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
308            stream.expect_string("bar")?;
309            let saved_pos = stream.position();
310            let cta = stream.expect_string(".cta").is_ok();
311            if !cta {
312                stream.set_position(saved_pos);
313            }
314            stream.expect_complete()?;
315            stream.expect_string(".arrive")?;
316            let arrive = ();
317            stream.expect_complete()?;
318            let a = GeneralOperand::parse(stream)?;
319            stream.expect_complete()?;
320            stream.expect(&PtxToken::Comma)?;
321            let b = GeneralOperand::parse(stream)?;
322            stream.expect_complete()?;
323            stream.expect_complete()?;
324            stream.expect(&PtxToken::Semicolon)?;
325            Ok(BarCtaArrive { cta, arrive, a, b })
326        }
327    }
328
329    impl PtxParser for BarCtaRedPopcU32 {
330        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
331            stream.expect_string("bar")?;
332            let saved_pos = stream.position();
333            let cta = stream.expect_string(".cta").is_ok();
334            if !cta {
335                stream.set_position(saved_pos);
336            }
337            stream.expect_complete()?;
338            stream.expect_string(".red")?;
339            let red = ();
340            stream.expect_complete()?;
341            stream.expect_string(".popc")?;
342            let popc = ();
343            stream.expect_complete()?;
344            stream.expect_string(".u32")?;
345            let u32 = ();
346            stream.expect_complete()?;
347            let d = GeneralOperand::parse(stream)?;
348            stream.expect_complete()?;
349            stream.expect(&PtxToken::Comma)?;
350            let a = GeneralOperand::parse(stream)?;
351            stream.expect_complete()?;
352            let saved_pos = stream.position();
353            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
354            if !has_comma {
355                stream.set_position(saved_pos);
356            }
357            let saved_pos = stream.position();
358            let b = match GeneralOperand::parse(stream) {
359                Ok(val) => Some(val),
360                Err(_) => {
361                    stream.set_position(saved_pos);
362                    None
363                }
364            };
365            stream.expect_complete()?;
366            stream.expect(&PtxToken::Comma)?;
367            let c_op = stream
368                .consume_if(|t| matches!(t, PtxToken::Exclaim))
369                .is_some();
370            let c = GeneralOperand::parse(stream)?;
371            stream.expect_complete()?;
372            stream.expect_complete()?;
373            stream.expect(&PtxToken::Semicolon)?;
374            Ok(BarCtaRedPopcU32 {
375                cta,
376                red,
377                popc,
378                u32,
379                d,
380                a,
381                b,
382                c_op,
383                c,
384            })
385        }
386    }
387
388    impl PtxParser for BarCtaRedOpPred {
389        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
390            stream.expect_string("bar")?;
391            let saved_pos = stream.position();
392            let cta = stream.expect_string(".cta").is_ok();
393            if !cta {
394                stream.set_position(saved_pos);
395            }
396            stream.expect_complete()?;
397            stream.expect_string(".red")?;
398            let red = ();
399            stream.expect_complete()?;
400            let op = Op::parse(stream)?;
401            stream.expect_complete()?;
402            stream.expect_string(".pred")?;
403            let pred = ();
404            stream.expect_complete()?;
405            let p = GeneralOperand::parse(stream)?;
406            stream.expect_complete()?;
407            stream.expect(&PtxToken::Comma)?;
408            let a = GeneralOperand::parse(stream)?;
409            stream.expect_complete()?;
410            let saved_pos = stream.position();
411            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
412            if !has_comma {
413                stream.set_position(saved_pos);
414            }
415            let saved_pos = stream.position();
416            let b = match GeneralOperand::parse(stream) {
417                Ok(val) => Some(val),
418                Err(_) => {
419                    stream.set_position(saved_pos);
420                    None
421                }
422            };
423            stream.expect_complete()?;
424            stream.expect(&PtxToken::Comma)?;
425            let c_op = stream
426                .consume_if(|t| matches!(t, PtxToken::Exclaim))
427                .is_some();
428            let c = GeneralOperand::parse(stream)?;
429            stream.expect_complete()?;
430            stream.expect_complete()?;
431            stream.expect(&PtxToken::Semicolon)?;
432            Ok(BarCtaRedOpPred {
433                cta,
434                red,
435                op,
436                pred,
437                p,
438                a,
439                b,
440                c_op,
441                c,
442            })
443        }
444    }
445}
ptx_parser/parser/instruction/bar.rs

ptx_parser/parser/instruction/
bar.rs
