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::parser::{
16    PtxParseError, PtxParser, PtxTokenStream, Span,
17    util::{
18        between, comma_p, directive_p, exclamation_p, lbracket_p, lparen_p, map, minus_p, optional,
19        pipe_p, rbracket_p, rparen_p, semicolon_p, sep_by, string_p, try_map,
20    },
21};
22use crate::r#type::common::*;
23use crate::{alt, ok, seq_n};
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::bar::section_0::*;
28
29    // ============================================================================
30    // Generated enum parsers
31    // ============================================================================
32
33    impl PtxParser for Op {
34        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
35            alt!(
36                map(string_p(".and"), |_, _span| Op::And),
37                map(string_p(".or"), |_, _span| Op::Or)
38            )
39        }
40    }
41
42    impl PtxParser for BarrierCtaSyncAligned {
43        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
44            try_map(
45                seq_n!(
46                    string_p("barrier"),
47                    map(optional(string_p(".cta")), |value, _| value.is_some()),
48                    string_p(".sync"),
49                    map(optional(string_p(".aligned")), |value, _| value.is_some()),
50                    GeneralOperand::parse(),
51                    map(
52                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
53                        |value, _| value.map(|(_, operand)| operand)
54                    ),
55                    semicolon_p()
56                ),
57                |(_, cta, sync, aligned, a, b, _), span| {
58                    ok!(BarrierCtaSyncAligned {
59                        cta = cta,
60                        sync = sync,
61                        aligned = aligned,
62                        a = a,
63                        b = b,
64
65                    })
66                },
67            )
68        }
69    }
70
71    impl PtxParser for BarrierCtaArriveAligned {
72        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
73            try_map(
74                seq_n!(
75                    string_p("barrier"),
76                    map(optional(string_p(".cta")), |value, _| value.is_some()),
77                    string_p(".arrive"),
78                    map(optional(string_p(".aligned")), |value, _| value.is_some()),
79                    GeneralOperand::parse(),
80                    comma_p(),
81                    GeneralOperand::parse(),
82                    semicolon_p()
83                ),
84                |(_, cta, arrive, aligned, a, _, b, _), span| {
85                    ok!(BarrierCtaArriveAligned {
86                        cta = cta,
87                        arrive = arrive,
88                        aligned = aligned,
89                        a = a,
90                        b = b,
91
92                    })
93                },
94            )
95        }
96    }
97
98    impl PtxParser for BarrierCtaRedPopcAlignedU32 {
99        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
100            try_map(
101                seq_n!(
102                    string_p("barrier"),
103                    map(optional(string_p(".cta")), |value, _| value.is_some()),
104                    string_p(".red"),
105                    string_p(".popc"),
106                    map(optional(string_p(".aligned")), |value, _| value.is_some()),
107                    string_p(".u32"),
108                    GeneralOperand::parse(),
109                    comma_p(),
110                    GeneralOperand::parse(),
111                    map(
112                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
113                        |value, _| value.map(|(_, operand)| operand)
114                    ),
115                    comma_p(),
116                    map(optional(exclamation_p()), |value, _| value.is_some()),
117                    GeneralOperand::parse(),
118                    semicolon_p()
119                ),
120                |(_, cta, red, popc, aligned, u32, d, _, a, b, _, c_op, c, _), span| {
121                    ok!(BarrierCtaRedPopcAlignedU32 {
122                        cta = cta,
123                        red = red,
124                        popc = popc,
125                        aligned = aligned,
126                        u32 = u32,
127                        d = d,
128                        a = a,
129                        b = b,
130                        c_op = c_op,
131                        c = c,
132
133                    })
134                },
135            )
136        }
137    }
138
139    impl PtxParser for BarrierCtaRedOpAlignedPred {
140        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
141            try_map(
142                seq_n!(
143                    string_p("barrier"),
144                    map(optional(string_p(".cta")), |value, _| value.is_some()),
145                    string_p(".red"),
146                    Op::parse(),
147                    map(optional(string_p(".aligned")), |value, _| value.is_some()),
148                    string_p(".pred"),
149                    GeneralOperand::parse(),
150                    comma_p(),
151                    GeneralOperand::parse(),
152                    map(
153                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
154                        |value, _| value.map(|(_, operand)| operand)
155                    ),
156                    comma_p(),
157                    map(optional(exclamation_p()), |value, _| value.is_some()),
158                    GeneralOperand::parse(),
159                    semicolon_p()
160                ),
161                |(_, cta, red, op, aligned, pred, p, _, a, b, _, c_op, c, _), span| {
162                    ok!(BarrierCtaRedOpAlignedPred {
163                        cta = cta,
164                        red = red,
165                        op = op,
166                        aligned = aligned,
167                        pred = pred,
168                        p = p,
169                        a = a,
170                        b = b,
171                        c_op = c_op,
172                        c = c,
173
174                    })
175                },
176            )
177        }
178    }
179
180    impl PtxParser for BarCtaSync {
181        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
182            try_map(
183                seq_n!(
184                    string_p("bar"),
185                    map(optional(string_p(".cta")), |value, _| value.is_some()),
186                    string_p(".sync"),
187                    GeneralOperand::parse(),
188                    map(
189                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
190                        |value, _| value.map(|(_, operand)| operand)
191                    ),
192                    semicolon_p()
193                ),
194                |(_, cta, sync, a, b, _), span| {
195                    ok!(BarCtaSync {
196                        cta = cta,
197                        sync = sync,
198                        a = a,
199                        b = b,
200
201                    })
202                },
203            )
204        }
205    }
206
207    impl PtxParser for BarCtaArrive {
208        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
209            try_map(
210                seq_n!(
211                    string_p("bar"),
212                    map(optional(string_p(".cta")), |value, _| value.is_some()),
213                    string_p(".arrive"),
214                    GeneralOperand::parse(),
215                    comma_p(),
216                    GeneralOperand::parse(),
217                    semicolon_p()
218                ),
219                |(_, cta, arrive, a, _, b, _), span| {
220                    ok!(BarCtaArrive {
221                        cta = cta,
222                        arrive = arrive,
223                        a = a,
224                        b = b,
225
226                    })
227                },
228            )
229        }
230    }
231
232    impl PtxParser for BarCtaRedPopcU32 {
233        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
234            try_map(
235                seq_n!(
236                    string_p("bar"),
237                    map(optional(string_p(".cta")), |value, _| value.is_some()),
238                    string_p(".red"),
239                    string_p(".popc"),
240                    string_p(".u32"),
241                    GeneralOperand::parse(),
242                    comma_p(),
243                    GeneralOperand::parse(),
244                    map(
245                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
246                        |value, _| value.map(|(_, operand)| operand)
247                    ),
248                    comma_p(),
249                    map(optional(exclamation_p()), |value, _| value.is_some()),
250                    GeneralOperand::parse(),
251                    semicolon_p()
252                ),
253                |(_, cta, red, popc, u32, d, _, a, b, _, c_op, c, _), span| {
254                    ok!(BarCtaRedPopcU32 {
255                        cta = cta,
256                        red = red,
257                        popc = popc,
258                        u32 = u32,
259                        d = d,
260                        a = a,
261                        b = b,
262                        c_op = c_op,
263                        c = c,
264
265                    })
266                },
267            )
268        }
269    }
270
271    impl PtxParser for BarCtaRedOpPred {
272        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
273            try_map(
274                seq_n!(
275                    string_p("bar"),
276                    map(optional(string_p(".cta")), |value, _| value.is_some()),
277                    string_p(".red"),
278                    Op::parse(),
279                    string_p(".pred"),
280                    GeneralOperand::parse(),
281                    comma_p(),
282                    GeneralOperand::parse(),
283                    map(
284                        optional(seq_n!(comma_p(), GeneralOperand::parse())),
285                        |value, _| value.map(|(_, operand)| operand)
286                    ),
287                    comma_p(),
288                    map(optional(exclamation_p()), |value, _| value.is_some()),
289                    GeneralOperand::parse(),
290                    semicolon_p()
291                ),
292                |(_, cta, red, op, pred, p, _, a, b, _, c_op, c, _), span| {
293                    ok!(BarCtaRedOpPred {
294                        cta = cta,
295                        red = red,
296                        op = op,
297                        pred = pred,
298                        p = p,
299                        a = a,
300                        b = b,
301                        c_op = c_op,
302                        c = c,
303
304                    })
305                },
306            )
307        }
308    }
309}
ptx_parser/parser/instruction/bar.rs

ptx_parser/parser/instruction/
bar.rs
