ptx_parser/parser/instruction/
min.rs

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

ptx_parser/parser/instruction/
min.rs
