ptx_parser/parser/instruction/
max.rs

1//! Original PTX specification:
2//!
3//! max.atype         d, a, b;
4//! max{.relu}.btype  d, a, b;
5//! .atype = { .u16, .u32, .u64,
6//! .u16x2, .s16, .s64 };
7//! .btype = { .s16x2, .s32 };
8//!
9//! max{.ftz}{.NaN}{.xorsign.abs}.f32  d, a, b;
10//! max{.ftz}{.NaN}{.abs}.f32          d, a, b, c;
11//! max.f64                            d, a, b;
12//!
13//! max{.ftz}{.NaN}{.xorsign.abs}.f16      d, a, b;
14//! max{.ftz}{.NaN}{.xorsign.abs}.f16x2    d, a, b;
15//! max{.NaN}{.xorsign.abs}.bf16           d, a, b;
16//! max{.NaN}{.xorsign.abs}.bf16x2         d, a, b;
17
18#![allow(unused)]
19
20use crate::parser::{
21    PtxParseError, PtxParser, PtxTokenStream, Span,
22    util::{
23        between, comma_p, directive_p, exclamation_p, lbracket_p, lparen_p, map, minus_p, optional,
24        pipe_p, rbracket_p, rparen_p, semicolon_p, sep_by, string_p, try_map,
25    },
26};
27use crate::r#type::common::*;
28use crate::{alt, ok, seq_n};
29
30pub mod section_0 {
31    use super::*;
32    use crate::r#type::instruction::max::section_0::*;
33
34    // ============================================================================
35    // Generated enum parsers
36    // ============================================================================
37
38    impl PtxParser for Atype {
39        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
40            alt!(
41                map(string_p(".u16x2"), |_, _span| Atype::U16x2),
42                map(string_p(".u16"), |_, _span| Atype::U16),
43                map(string_p(".u32"), |_, _span| Atype::U32),
44                map(string_p(".u64"), |_, _span| Atype::U64),
45                map(string_p(".s16"), |_, _span| Atype::S16),
46                map(string_p(".s64"), |_, _span| Atype::S64)
47            )
48        }
49    }
50
51    impl PtxParser for Btype {
52        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
53            alt!(
54                map(string_p(".s16x2"), |_, _span| Btype::S16x2),
55                map(string_p(".s32"), |_, _span| Btype::S32)
56            )
57        }
58    }
59
60    impl PtxParser for MaxAtype {
61        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
62            try_map(
63                seq_n!(
64                    string_p("max"),
65                    Atype::parse(),
66                    GeneralOperand::parse(),
67                    comma_p(),
68                    GeneralOperand::parse(),
69                    comma_p(),
70                    GeneralOperand::parse(),
71                    semicolon_p()
72                ),
73                |(_, atype, d, _, a, _, b, _), span| {
74                    ok!(MaxAtype {
75                        atype = atype,
76                        d = d,
77                        a = a,
78                        b = b,
79
80                    })
81                },
82            )
83        }
84    }
85
86    impl PtxParser for MaxReluBtype {
87        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
88            try_map(
89                seq_n!(
90                    string_p("max"),
91                    map(optional(string_p(".relu")), |value, _| value.is_some()),
92                    Btype::parse(),
93                    GeneralOperand::parse(),
94                    comma_p(),
95                    GeneralOperand::parse(),
96                    comma_p(),
97                    GeneralOperand::parse(),
98                    semicolon_p()
99                ),
100                |(_, relu, btype, d, _, a, _, b, _), span| {
101                    ok!(MaxReluBtype {
102                        relu = relu,
103                        btype = btype,
104                        d = d,
105                        a = a,
106                        b = b,
107
108                    })
109                },
110            )
111        }
112    }
113
114    impl PtxParser for MaxFtzNanXorsignAbsF32 {
115        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
116            try_map(
117                seq_n!(
118                    string_p("max"),
119                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
120                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
121                    map(optional(string_p(".xorsign.abs")), |value, _| value
122                        .is_some()),
123                    string_p(".f32"),
124                    GeneralOperand::parse(),
125                    comma_p(),
126                    GeneralOperand::parse(),
127                    comma_p(),
128                    GeneralOperand::parse(),
129                    semicolon_p()
130                ),
131                |(_, ftz, nan, xorsign_abs, f32, d, _, a, _, b, _), span| {
132                    ok!(MaxFtzNanXorsignAbsF32 {
133                        ftz = ftz,
134                        nan = nan,
135                        xorsign_abs = xorsign_abs,
136                        f32 = f32,
137                        d = d,
138                        a = a,
139                        b = b,
140
141                    })
142                },
143            )
144        }
145    }
146
147    impl PtxParser for MaxFtzNanAbsF32 {
148        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
149            try_map(
150                seq_n!(
151                    string_p("max"),
152                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
153                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
154                    map(optional(string_p(".abs")), |value, _| value.is_some()),
155                    string_p(".f32"),
156                    GeneralOperand::parse(),
157                    comma_p(),
158                    GeneralOperand::parse(),
159                    comma_p(),
160                    GeneralOperand::parse(),
161                    comma_p(),
162                    GeneralOperand::parse(),
163                    semicolon_p()
164                ),
165                |(_, ftz, nan, abs, f32, d, _, a, _, b, _, c, _), span| {
166                    ok!(MaxFtzNanAbsF32 {
167                        ftz = ftz,
168                        nan = nan,
169                        abs = abs,
170                        f32 = f32,
171                        d = d,
172                        a = a,
173                        b = b,
174                        c = c,
175
176                    })
177                },
178            )
179        }
180    }
181
182    impl PtxParser for MaxF64 {
183        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
184            try_map(
185                seq_n!(
186                    string_p("max"),
187                    string_p(".f64"),
188                    GeneralOperand::parse(),
189                    comma_p(),
190                    GeneralOperand::parse(),
191                    comma_p(),
192                    GeneralOperand::parse(),
193                    semicolon_p()
194                ),
195                |(_, f64, d, _, a, _, b, _), span| {
196                    ok!(MaxF64 {
197                        f64 = f64,
198                        d = d,
199                        a = a,
200                        b = b,
201
202                    })
203                },
204            )
205        }
206    }
207
208    impl PtxParser for MaxFtzNanXorsignAbsF16 {
209        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
210            try_map(
211                seq_n!(
212                    string_p("max"),
213                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
214                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
215                    map(optional(string_p(".xorsign.abs")), |value, _| value
216                        .is_some()),
217                    string_p(".f16"),
218                    GeneralOperand::parse(),
219                    comma_p(),
220                    GeneralOperand::parse(),
221                    comma_p(),
222                    GeneralOperand::parse(),
223                    semicolon_p()
224                ),
225                |(_, ftz, nan, xorsign_abs, f16, d, _, a, _, b, _), span| {
226                    ok!(MaxFtzNanXorsignAbsF16 {
227                        ftz = ftz,
228                        nan = nan,
229                        xorsign_abs = xorsign_abs,
230                        f16 = f16,
231                        d = d,
232                        a = a,
233                        b = b,
234
235                    })
236                },
237            )
238        }
239    }
240
241    impl PtxParser for MaxFtzNanXorsignAbsF16x2 {
242        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
243            try_map(
244                seq_n!(
245                    string_p("max"),
246                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
247                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
248                    map(optional(string_p(".xorsign.abs")), |value, _| value
249                        .is_some()),
250                    string_p(".f16x2"),
251                    GeneralOperand::parse(),
252                    comma_p(),
253                    GeneralOperand::parse(),
254                    comma_p(),
255                    GeneralOperand::parse(),
256                    semicolon_p()
257                ),
258                |(_, ftz, nan, xorsign_abs, f16x2, d, _, a, _, b, _), span| {
259                    ok!(MaxFtzNanXorsignAbsF16x2 {
260                        ftz = ftz,
261                        nan = nan,
262                        xorsign_abs = xorsign_abs,
263                        f16x2 = f16x2,
264                        d = d,
265                        a = a,
266                        b = b,
267
268                    })
269                },
270            )
271        }
272    }
273
274    impl PtxParser for MaxNanXorsignAbsBf16 {
275        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
276            try_map(
277                seq_n!(
278                    string_p("max"),
279                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
280                    map(optional(string_p(".xorsign.abs")), |value, _| value
281                        .is_some()),
282                    string_p(".bf16"),
283                    GeneralOperand::parse(),
284                    comma_p(),
285                    GeneralOperand::parse(),
286                    comma_p(),
287                    GeneralOperand::parse(),
288                    semicolon_p()
289                ),
290                |(_, nan, xorsign_abs, bf16, d, _, a, _, b, _), span| {
291                    ok!(MaxNanXorsignAbsBf16 {
292                        nan = nan,
293                        xorsign_abs = xorsign_abs,
294                        bf16 = bf16,
295                        d = d,
296                        a = a,
297                        b = b,
298
299                    })
300                },
301            )
302        }
303    }
304
305    impl PtxParser for MaxNanXorsignAbsBf16x2 {
306        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
307            try_map(
308                seq_n!(
309                    string_p("max"),
310                    map(optional(string_p(".NaN")), |value, _| value.is_some()),
311                    map(optional(string_p(".xorsign.abs")), |value, _| value
312                        .is_some()),
313                    string_p(".bf16x2"),
314                    GeneralOperand::parse(),
315                    comma_p(),
316                    GeneralOperand::parse(),
317                    comma_p(),
318                    GeneralOperand::parse(),
319                    semicolon_p()
320                ),
321                |(_, nan, xorsign_abs, bf16x2, d, _, a, _, b, _), span| {
322                    ok!(MaxNanXorsignAbsBf16x2 {
323                        nan = nan,
324                        xorsign_abs = xorsign_abs,
325                        bf16x2 = bf16x2,
326                        d = d,
327                        a = a,
328                        b = b,
329
330                    })
331                },
332            )
333        }
334    }
335}
ptx_parser/parser/instruction/max.rs

ptx_parser/parser/instruction/
max.rs
