ptx_parser/unparser/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::lexer::PtxToken;
24use crate::unparser::{PtxUnparser, common::*};
25
26pub mod section_0 {
27    use super::*;
28    use crate::r#type::instruction::fma::section_0::*;
29
30    impl PtxUnparser for FmaRndFtzSatF32 {
31        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
32            push_opcode(tokens, "fma");
33                    match &self.rnd {
34                            Rnd::Rn => {
35                                    push_directive(tokens, "rn");
36                            }
37                            Rnd::Rz => {
38                                    push_directive(tokens, "rz");
39                            }
40                            Rnd::Rm => {
41                                    push_directive(tokens, "rm");
42                            }
43                            Rnd::Rp => {
44                                    push_directive(tokens, "rp");
45                            }
46                    }
47                    if self.ftz {
48                            push_directive(tokens, "ftz");
49                    }
50                    if self.sat {
51                            push_directive(tokens, "sat");
52                    }
53                    push_directive(tokens, "f32");
54                    self.d.unparse_tokens(tokens);
55            tokens.push(PtxToken::Comma);
56                    self.a.unparse_tokens(tokens);
57            tokens.push(PtxToken::Comma);
58                    self.b.unparse_tokens(tokens);
59            tokens.push(PtxToken::Comma);
60                    self.c.unparse_tokens(tokens);
61            tokens.push(PtxToken::Semicolon);
62        }
63    }
64
65    impl PtxUnparser for FmaRndFtzF32x2 {
66        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
67            push_opcode(tokens, "fma");
68                    match &self.rnd {
69                            Rnd::Rn => {
70                                    push_directive(tokens, "rn");
71                            }
72                            Rnd::Rz => {
73                                    push_directive(tokens, "rz");
74                            }
75                            Rnd::Rm => {
76                                    push_directive(tokens, "rm");
77                            }
78                            Rnd::Rp => {
79                                    push_directive(tokens, "rp");
80                            }
81                    }
82                    if self.ftz {
83                            push_directive(tokens, "ftz");
84                    }
85                    push_directive(tokens, "f32x2");
86                    self.d.unparse_tokens(tokens);
87            tokens.push(PtxToken::Comma);
88                    self.a.unparse_tokens(tokens);
89            tokens.push(PtxToken::Comma);
90                    self.b.unparse_tokens(tokens);
91            tokens.push(PtxToken::Comma);
92                    self.c.unparse_tokens(tokens);
93            tokens.push(PtxToken::Semicolon);
94        }
95    }
96
97    impl PtxUnparser for FmaRndF64 {
98        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
99            push_opcode(tokens, "fma");
100                    match &self.rnd {
101                            Rnd::Rn => {
102                                    push_directive(tokens, "rn");
103                            }
104                            Rnd::Rz => {
105                                    push_directive(tokens, "rz");
106                            }
107                            Rnd::Rm => {
108                                    push_directive(tokens, "rm");
109                            }
110                            Rnd::Rp => {
111                                    push_directive(tokens, "rp");
112                            }
113                    }
114                    push_directive(tokens, "f64");
115                    self.d.unparse_tokens(tokens);
116            tokens.push(PtxToken::Comma);
117                    self.a.unparse_tokens(tokens);
118            tokens.push(PtxToken::Comma);
119                    self.b.unparse_tokens(tokens);
120            tokens.push(PtxToken::Comma);
121                    self.c.unparse_tokens(tokens);
122            tokens.push(PtxToken::Semicolon);
123        }
124    }
125
126}
127
128pub mod section_1 {
129    use super::*;
130    use crate::r#type::instruction::fma::section_1::*;
131
132    impl PtxUnparser for FmaRndFtzSatF16 {
133        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
134            push_opcode(tokens, "fma");
135                    match &self.rnd {
136                            Rnd::Rn => {
137                                    push_directive(tokens, "rn");
138                            }
139                    }
140                    if self.ftz {
141                            push_directive(tokens, "ftz");
142                    }
143                    if self.sat {
144                            push_directive(tokens, "sat");
145                    }
146                    push_directive(tokens, "f16");
147                    self.d.unparse_tokens(tokens);
148            tokens.push(PtxToken::Comma);
149                    self.a.unparse_tokens(tokens);
150            tokens.push(PtxToken::Comma);
151                    self.b.unparse_tokens(tokens);
152            tokens.push(PtxToken::Comma);
153                    self.c.unparse_tokens(tokens);
154            tokens.push(PtxToken::Semicolon);
155        }
156    }
157
158    impl PtxUnparser for FmaRndFtzSatF16x2 {
159        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
160            push_opcode(tokens, "fma");
161                    match &self.rnd {
162                            Rnd::Rn => {
163                                    push_directive(tokens, "rn");
164                            }
165                    }
166                    if self.ftz {
167                            push_directive(tokens, "ftz");
168                    }
169                    if self.sat {
170                            push_directive(tokens, "sat");
171                    }
172                    push_directive(tokens, "f16x2");
173                    self.d.unparse_tokens(tokens);
174            tokens.push(PtxToken::Comma);
175                    self.a.unparse_tokens(tokens);
176            tokens.push(PtxToken::Comma);
177                    self.b.unparse_tokens(tokens);
178            tokens.push(PtxToken::Comma);
179                    self.c.unparse_tokens(tokens);
180            tokens.push(PtxToken::Semicolon);
181        }
182    }
183
184    impl PtxUnparser for FmaRndFtzReluF16 {
185        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
186            push_opcode(tokens, "fma");
187                    match &self.rnd {
188                            Rnd::Rn => {
189                                    push_directive(tokens, "rn");
190                            }
191                    }
192                    if self.ftz {
193                            push_directive(tokens, "ftz");
194                    }
195                    push_directive(tokens, "relu");
196                    push_directive(tokens, "f16");
197                    self.d.unparse_tokens(tokens);
198            tokens.push(PtxToken::Comma);
199                    self.a.unparse_tokens(tokens);
200            tokens.push(PtxToken::Comma);
201                    self.b.unparse_tokens(tokens);
202            tokens.push(PtxToken::Comma);
203                    self.c.unparse_tokens(tokens);
204            tokens.push(PtxToken::Semicolon);
205        }
206    }
207
208    impl PtxUnparser for FmaRndFtzReluF16x2 {
209        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
210            push_opcode(tokens, "fma");
211                    match &self.rnd {
212                            Rnd::Rn => {
213                                    push_directive(tokens, "rn");
214                            }
215                    }
216                    if self.ftz {
217                            push_directive(tokens, "ftz");
218                    }
219                    push_directive(tokens, "relu");
220                    push_directive(tokens, "f16x2");
221                    self.d.unparse_tokens(tokens);
222            tokens.push(PtxToken::Comma);
223                    self.a.unparse_tokens(tokens);
224            tokens.push(PtxToken::Comma);
225                    self.b.unparse_tokens(tokens);
226            tokens.push(PtxToken::Comma);
227                    self.c.unparse_tokens(tokens);
228            tokens.push(PtxToken::Semicolon);
229        }
230    }
231
232    impl PtxUnparser for FmaRndReluBf16 {
233        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
234            push_opcode(tokens, "fma");
235                    match &self.rnd {
236                            Rnd::Rn => {
237                                    push_directive(tokens, "rn");
238                            }
239                    }
240                    if self.relu {
241                            push_directive(tokens, "relu");
242                    }
243                    push_directive(tokens, "bf16");
244                    self.d.unparse_tokens(tokens);
245            tokens.push(PtxToken::Comma);
246                    self.a.unparse_tokens(tokens);
247            tokens.push(PtxToken::Comma);
248                    self.b.unparse_tokens(tokens);
249            tokens.push(PtxToken::Comma);
250                    self.c.unparse_tokens(tokens);
251            tokens.push(PtxToken::Semicolon);
252        }
253    }
254
255    impl PtxUnparser for FmaRndReluBf16x2 {
256        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
257            push_opcode(tokens, "fma");
258                    match &self.rnd {
259                            Rnd::Rn => {
260                                    push_directive(tokens, "rn");
261                            }
262                    }
263                    if self.relu {
264                            push_directive(tokens, "relu");
265                    }
266                    push_directive(tokens, "bf16x2");
267                    self.d.unparse_tokens(tokens);
268            tokens.push(PtxToken::Comma);
269                    self.a.unparse_tokens(tokens);
270            tokens.push(PtxToken::Comma);
271                    self.b.unparse_tokens(tokens);
272            tokens.push(PtxToken::Comma);
273                    self.c.unparse_tokens(tokens);
274            tokens.push(PtxToken::Semicolon);
275        }
276    }
277
278    impl PtxUnparser for FmaRndOobReluType {
279        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
280            push_opcode(tokens, "fma");
281                    match &self.rnd {
282                            Rnd::Rn => {
283                                    push_directive(tokens, "rn");
284                            }
285                    }
286                    push_directive(tokens, "oob");
287                    if self.relu {
288                            push_directive(tokens, "relu");
289                    }
290                    push_directive(tokens, "type");
291                    self.d.unparse_tokens(tokens);
292            tokens.push(PtxToken::Comma);
293                    self.a.unparse_tokens(tokens);
294            tokens.push(PtxToken::Comma);
295                    self.b.unparse_tokens(tokens);
296            tokens.push(PtxToken::Comma);
297                    self.c.unparse_tokens(tokens);
298            tokens.push(PtxToken::Semicolon);
299        }
300    }
301
302}
303
304pub mod section_2 {
305    use super::*;
306    use crate::r#type::instruction::fma::section_2::*;
307
308    impl PtxUnparser for FmaRndSatF32Abtype {
309        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
310            push_opcode(tokens, "fma");
311                    match &self.rnd {
312                            Rnd::Rn => {
313                                    push_directive(tokens, "rn");
314                            }
315                            Rnd::Rz => {
316                                    push_directive(tokens, "rz");
317                            }
318                            Rnd::Rm => {
319                                    push_directive(tokens, "rm");
320                            }
321                            Rnd::Rp => {
322                                    push_directive(tokens, "rp");
323                            }
324                    }
325                    if self.sat {
326                            push_directive(tokens, "sat");
327                    }
328                    push_directive(tokens, "f32");
329                    match &self.abtype {
330                            Abtype::Bf16 => {
331                                    push_directive(tokens, "bf16");
332                            }
333                            Abtype::F16 => {
334                                    push_directive(tokens, "f16");
335                            }
336                    }
337                    self.d.unparse_tokens(tokens);
338            tokens.push(PtxToken::Comma);
339                    self.a.unparse_tokens(tokens);
340            tokens.push(PtxToken::Comma);
341                    self.b.unparse_tokens(tokens);
342            tokens.push(PtxToken::Comma);
343                    self.c.unparse_tokens(tokens);
344            tokens.push(PtxToken::Semicolon);
345        }
346    }
347
348}
349
ptx_parser/unparser/instruction/fma.rs

ptx_parser/unparser/instruction/
fma.rs
