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

ptx_parser/parser/instruction/
bar.rs
