ptx_parser/parser/instruction/
fma.rs

1//! Original PTX specification:
2//!
3//! fma.rnd{.ftz}{.sat}.f32  d, a, b, c;
4//! fma.rnd{.ftz}.f32x2      d, a, b, c;
5//! fma.rnd.f64              d, a, b, c;
6//! .rnd = { .rn, .rz, .rm, .rp };
7//! ---------------------------------------------
8//! fma.rnd{.ftz}{.sat}.f16     d, a, b, c;
9//! fma.rnd{.ftz}{.sat}.f16x2   d, a, b, c;
10//! fma.rnd{.ftz}.relu.f16      d, a, b, c;
11//! fma.rnd{.ftz}.relu.f16x2    d, a, b, c;
12//! fma.rnd{.relu}.bf16         d, a, b, c;
13//! fma.rnd{.relu}.bf16x2       d, a, b, c;
14//! fma.rnd.oob{.relu}.type     d, a, b, c;
15//! .rnd = { .rn };
16//! ---------------------------------------------
17//! fma.rnd{.sat}.f32.abtype  d, a, b, c;
18//! .abtype = { .f16, .bf16};
19//! .rnd    = { .rn, .rz, .rm, .rp };
20
21#![allow(unused)]
22
23use crate::parser::{
24    PtxParseError, PtxParser, PtxTokenStream, Span,
25    util::{
26        between, comma_p, directive_p, exclamation_p, lbracket_p, lparen_p, map, minus_p, optional,
27        pipe_p, rbracket_p, rparen_p, semicolon_p, sep_by, string_p, try_map,
28    },
29};
30use crate::r#type::common::*;
31use crate::{alt, ok, seq_n};
32
33pub mod section_0 {
34    use super::*;
35    use crate::r#type::instruction::fma::section_0::*;
36
37    // ============================================================================
38    // Generated enum parsers
39    // ============================================================================
40
41    impl PtxParser for Rnd {
42        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
43            alt!(
44                map(string_p(".rn"), |_, _span| Rnd::Rn),
45                map(string_p(".rz"), |_, _span| Rnd::Rz),
46                map(string_p(".rm"), |_, _span| Rnd::Rm),
47                map(string_p(".rp"), |_, _span| Rnd::Rp)
48            )
49        }
50    }
51
52    impl PtxParser for FmaRndFtzSatF32 {
53        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
54            try_map(
55                seq_n!(
56                    string_p("fma"),
57                    Rnd::parse(),
58                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
59                    map(optional(string_p(".sat")), |value, _| value.is_some()),
60                    string_p(".f32"),
61                    GeneralOperand::parse(),
62                    comma_p(),
63                    GeneralOperand::parse(),
64                    comma_p(),
65                    GeneralOperand::parse(),
66                    comma_p(),
67                    GeneralOperand::parse(),
68                    semicolon_p()
69                ),
70                |(_, rnd, ftz, sat, f32, d, _, a, _, b, _, c, _), span| {
71                    ok!(FmaRndFtzSatF32 {
72                        rnd = rnd,
73                        ftz = ftz,
74                        sat = sat,
75                        f32 = f32,
76                        d = d,
77                        a = a,
78                        b = b,
79                        c = c,
80
81                    })
82                },
83            )
84        }
85    }
86
87    impl PtxParser for FmaRndFtzF32x2 {
88        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
89            try_map(
90                seq_n!(
91                    string_p("fma"),
92                    Rnd::parse(),
93                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
94                    string_p(".f32x2"),
95                    GeneralOperand::parse(),
96                    comma_p(),
97                    GeneralOperand::parse(),
98                    comma_p(),
99                    GeneralOperand::parse(),
100                    comma_p(),
101                    GeneralOperand::parse(),
102                    semicolon_p()
103                ),
104                |(_, rnd, ftz, f32x2, d, _, a, _, b, _, c, _), span| {
105                    ok!(FmaRndFtzF32x2 {
106                        rnd = rnd,
107                        ftz = ftz,
108                        f32x2 = f32x2,
109                        d = d,
110                        a = a,
111                        b = b,
112                        c = c,
113
114                    })
115                },
116            )
117        }
118    }
119
120    impl PtxParser for FmaRndF64 {
121        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
122            try_map(
123                seq_n!(
124                    string_p("fma"),
125                    Rnd::parse(),
126                    string_p(".f64"),
127                    GeneralOperand::parse(),
128                    comma_p(),
129                    GeneralOperand::parse(),
130                    comma_p(),
131                    GeneralOperand::parse(),
132                    comma_p(),
133                    GeneralOperand::parse(),
134                    semicolon_p()
135                ),
136                |(_, rnd, f64, d, _, a, _, b, _, c, _), span| {
137                    ok!(FmaRndF64 {
138                        rnd = rnd,
139                        f64 = f64,
140                        d = d,
141                        a = a,
142                        b = b,
143                        c = c,
144
145                    })
146                },
147            )
148        }
149    }
150}
151
152pub mod section_1 {
153    use super::*;
154    use crate::r#type::instruction::fma::section_1::*;
155
156    // ============================================================================
157    // Generated enum parsers
158    // ============================================================================
159
160    impl PtxParser for Rnd {
161        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
162            alt!(map(string_p(".rn"), |_, _span| Rnd::Rn))
163        }
164    }
165
166    impl PtxParser for FmaRndFtzSatF16 {
167        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
168            try_map(
169                seq_n!(
170                    string_p("fma"),
171                    Rnd::parse(),
172                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
173                    map(optional(string_p(".sat")), |value, _| value.is_some()),
174                    string_p(".f16"),
175                    GeneralOperand::parse(),
176                    comma_p(),
177                    GeneralOperand::parse(),
178                    comma_p(),
179                    GeneralOperand::parse(),
180                    comma_p(),
181                    GeneralOperand::parse(),
182                    semicolon_p()
183                ),
184                |(_, rnd, ftz, sat, f16, d, _, a, _, b, _, c, _), span| {
185                    ok!(FmaRndFtzSatF16 {
186                        rnd = rnd,
187                        ftz = ftz,
188                        sat = sat,
189                        f16 = f16,
190                        d = d,
191                        a = a,
192                        b = b,
193                        c = c,
194
195                    })
196                },
197            )
198        }
199    }
200
201    impl PtxParser for FmaRndFtzSatF16x2 {
202        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
203            try_map(
204                seq_n!(
205                    string_p("fma"),
206                    Rnd::parse(),
207                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
208                    map(optional(string_p(".sat")), |value, _| value.is_some()),
209                    string_p(".f16x2"),
210                    GeneralOperand::parse(),
211                    comma_p(),
212                    GeneralOperand::parse(),
213                    comma_p(),
214                    GeneralOperand::parse(),
215                    comma_p(),
216                    GeneralOperand::parse(),
217                    semicolon_p()
218                ),
219                |(_, rnd, ftz, sat, f16x2, d, _, a, _, b, _, c, _), span| {
220                    ok!(FmaRndFtzSatF16x2 {
221                        rnd = rnd,
222                        ftz = ftz,
223                        sat = sat,
224                        f16x2 = f16x2,
225                        d = d,
226                        a = a,
227                        b = b,
228                        c = c,
229
230                    })
231                },
232            )
233        }
234    }
235
236    impl PtxParser for FmaRndFtzReluF16 {
237        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
238            try_map(
239                seq_n!(
240                    string_p("fma"),
241                    Rnd::parse(),
242                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
243                    string_p(".relu"),
244                    string_p(".f16"),
245                    GeneralOperand::parse(),
246                    comma_p(),
247                    GeneralOperand::parse(),
248                    comma_p(),
249                    GeneralOperand::parse(),
250                    comma_p(),
251                    GeneralOperand::parse(),
252                    semicolon_p()
253                ),
254                |(_, rnd, ftz, relu, f16, d, _, a, _, b, _, c, _), span| {
255                    ok!(FmaRndFtzReluF16 {
256                        rnd = rnd,
257                        ftz = ftz,
258                        relu = relu,
259                        f16 = f16,
260                        d = d,
261                        a = a,
262                        b = b,
263                        c = c,
264
265                    })
266                },
267            )
268        }
269    }
270
271    impl PtxParser for FmaRndFtzReluF16x2 {
272        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
273            try_map(
274                seq_n!(
275                    string_p("fma"),
276                    Rnd::parse(),
277                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
278                    string_p(".relu"),
279                    string_p(".f16x2"),
280                    GeneralOperand::parse(),
281                    comma_p(),
282                    GeneralOperand::parse(),
283                    comma_p(),
284                    GeneralOperand::parse(),
285                    comma_p(),
286                    GeneralOperand::parse(),
287                    semicolon_p()
288                ),
289                |(_, rnd, ftz, relu, f16x2, d, _, a, _, b, _, c, _), span| {
290                    ok!(FmaRndFtzReluF16x2 {
291                        rnd = rnd,
292                        ftz = ftz,
293                        relu = relu,
294                        f16x2 = f16x2,
295                        d = d,
296                        a = a,
297                        b = b,
298                        c = c,
299
300                    })
301                },
302            )
303        }
304    }
305
306    impl PtxParser for FmaRndReluBf16 {
307        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
308            try_map(
309                seq_n!(
310                    string_p("fma"),
311                    Rnd::parse(),
312                    map(optional(string_p(".relu")), |value, _| value.is_some()),
313                    string_p(".bf16"),
314                    GeneralOperand::parse(),
315                    comma_p(),
316                    GeneralOperand::parse(),
317                    comma_p(),
318                    GeneralOperand::parse(),
319                    comma_p(),
320                    GeneralOperand::parse(),
321                    semicolon_p()
322                ),
323                |(_, rnd, relu, bf16, d, _, a, _, b, _, c, _), span| {
324                    ok!(FmaRndReluBf16 {
325                        rnd = rnd,
326                        relu = relu,
327                        bf16 = bf16,
328                        d = d,
329                        a = a,
330                        b = b,
331                        c = c,
332
333                    })
334                },
335            )
336        }
337    }
338
339    impl PtxParser for FmaRndReluBf16x2 {
340        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
341            try_map(
342                seq_n!(
343                    string_p("fma"),
344                    Rnd::parse(),
345                    map(optional(string_p(".relu")), |value, _| value.is_some()),
346                    string_p(".bf16x2"),
347                    GeneralOperand::parse(),
348                    comma_p(),
349                    GeneralOperand::parse(),
350                    comma_p(),
351                    GeneralOperand::parse(),
352                    comma_p(),
353                    GeneralOperand::parse(),
354                    semicolon_p()
355                ),
356                |(_, rnd, relu, bf16x2, d, _, a, _, b, _, c, _), span| {
357                    ok!(FmaRndReluBf16x2 {
358                        rnd = rnd,
359                        relu = relu,
360                        bf16x2 = bf16x2,
361                        d = d,
362                        a = a,
363                        b = b,
364                        c = c,
365
366                    })
367                },
368            )
369        }
370    }
371
372    impl PtxParser for FmaRndOobReluType {
373        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
374            try_map(
375                seq_n!(
376                    string_p("fma"),
377                    Rnd::parse(),
378                    string_p(".oob"),
379                    map(optional(string_p(".relu")), |value, _| value.is_some()),
380                    string_p(".type"),
381                    GeneralOperand::parse(),
382                    comma_p(),
383                    GeneralOperand::parse(),
384                    comma_p(),
385                    GeneralOperand::parse(),
386                    comma_p(),
387                    GeneralOperand::parse(),
388                    semicolon_p()
389                ),
390                |(_, rnd, oob, relu, type_, d, _, a, _, b, _, c, _), span| {
391                    ok!(FmaRndOobReluType {
392                        rnd = rnd,
393                        oob = oob,
394                        relu = relu,
395                        type_ = type_,
396                        d = d,
397                        a = a,
398                        b = b,
399                        c = c,
400
401                    })
402                },
403            )
404        }
405    }
406}
407
408pub mod section_2 {
409    use super::*;
410    use crate::r#type::instruction::fma::section_2::*;
411
412    // ============================================================================
413    // Generated enum parsers
414    // ============================================================================
415
416    impl PtxParser for Abtype {
417        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
418            alt!(
419                map(string_p(".bf16"), |_, _span| Abtype::Bf16),
420                map(string_p(".f16"), |_, _span| Abtype::F16)
421            )
422        }
423    }
424
425    impl PtxParser for Rnd {
426        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
427            alt!(
428                map(string_p(".rn"), |_, _span| Rnd::Rn),
429                map(string_p(".rz"), |_, _span| Rnd::Rz),
430                map(string_p(".rm"), |_, _span| Rnd::Rm),
431                map(string_p(".rp"), |_, _span| Rnd::Rp)
432            )
433        }
434    }
435
436    impl PtxParser for FmaRndSatF32Abtype {
437        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
438            try_map(
439                seq_n!(
440                    string_p("fma"),
441                    Rnd::parse(),
442                    map(optional(string_p(".sat")), |value, _| value.is_some()),
443                    string_p(".f32"),
444                    Abtype::parse(),
445                    GeneralOperand::parse(),
446                    comma_p(),
447                    GeneralOperand::parse(),
448                    comma_p(),
449                    GeneralOperand::parse(),
450                    comma_p(),
451                    GeneralOperand::parse(),
452                    semicolon_p()
453                ),
454                |(_, rnd, sat, f32, abtype, d, _, a, _, b, _, c, _), span| {
455                    ok!(FmaRndSatF32Abtype {
456                        rnd = rnd,
457                        sat = sat,
458                        f32 = f32,
459                        abtype = abtype,
460                        d = d,
461                        a = a,
462                        b = b,
463                        c = c,
464
465                    })
466                },
467            )
468        }
469    }
470}
ptx_parser/parser/instruction/fma.rs

ptx_parser/parser/instruction/
fma.rs
