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
127pub mod section_1 {
128    use super::*;
129    use crate::r#type::instruction::fma::section_1::*;
130
131    impl PtxUnparser for FmaRndFtzSatF16 {
132        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
133            push_opcode(tokens, "fma");
134            match &self.rnd {
135                Rnd::Rn => {
136                    push_directive(tokens, "rn");
137                }
138            }
139            if self.ftz {
140                push_directive(tokens, "ftz");
141            }
142            if self.sat {
143                push_directive(tokens, "sat");
144            }
145            push_directive(tokens, "f16");
146            self.d.unparse_tokens(tokens);
147            tokens.push(PtxToken::Comma);
148            self.a.unparse_tokens(tokens);
149            tokens.push(PtxToken::Comma);
150            self.b.unparse_tokens(tokens);
151            tokens.push(PtxToken::Comma);
152            self.c.unparse_tokens(tokens);
153            tokens.push(PtxToken::Semicolon);
154        }
155    }
156
157    impl PtxUnparser for FmaRndFtzSatF16x2 {
158        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
159            push_opcode(tokens, "fma");
160            match &self.rnd {
161                Rnd::Rn => {
162                    push_directive(tokens, "rn");
163                }
164            }
165            if self.ftz {
166                push_directive(tokens, "ftz");
167            }
168            if self.sat {
169                push_directive(tokens, "sat");
170            }
171            push_directive(tokens, "f16x2");
172            self.d.unparse_tokens(tokens);
173            tokens.push(PtxToken::Comma);
174            self.a.unparse_tokens(tokens);
175            tokens.push(PtxToken::Comma);
176            self.b.unparse_tokens(tokens);
177            tokens.push(PtxToken::Comma);
178            self.c.unparse_tokens(tokens);
179            tokens.push(PtxToken::Semicolon);
180        }
181    }
182
183    impl PtxUnparser for FmaRndFtzReluF16 {
184        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
185            push_opcode(tokens, "fma");
186            match &self.rnd {
187                Rnd::Rn => {
188                    push_directive(tokens, "rn");
189                }
190            }
191            if self.ftz {
192                push_directive(tokens, "ftz");
193            }
194            push_directive(tokens, "relu");
195            push_directive(tokens, "f16");
196            self.d.unparse_tokens(tokens);
197            tokens.push(PtxToken::Comma);
198            self.a.unparse_tokens(tokens);
199            tokens.push(PtxToken::Comma);
200            self.b.unparse_tokens(tokens);
201            tokens.push(PtxToken::Comma);
202            self.c.unparse_tokens(tokens);
203            tokens.push(PtxToken::Semicolon);
204        }
205    }
206
207    impl PtxUnparser for FmaRndFtzReluF16x2 {
208        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
209            push_opcode(tokens, "fma");
210            match &self.rnd {
211                Rnd::Rn => {
212                    push_directive(tokens, "rn");
213                }
214            }
215            if self.ftz {
216                push_directive(tokens, "ftz");
217            }
218            push_directive(tokens, "relu");
219            push_directive(tokens, "f16x2");
220            self.d.unparse_tokens(tokens);
221            tokens.push(PtxToken::Comma);
222            self.a.unparse_tokens(tokens);
223            tokens.push(PtxToken::Comma);
224            self.b.unparse_tokens(tokens);
225            tokens.push(PtxToken::Comma);
226            self.c.unparse_tokens(tokens);
227            tokens.push(PtxToken::Semicolon);
228        }
229    }
230
231    impl PtxUnparser for FmaRndReluBf16 {
232        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
233            push_opcode(tokens, "fma");
234            match &self.rnd {
235                Rnd::Rn => {
236                    push_directive(tokens, "rn");
237                }
238            }
239            if self.relu {
240                push_directive(tokens, "relu");
241            }
242            push_directive(tokens, "bf16");
243            self.d.unparse_tokens(tokens);
244            tokens.push(PtxToken::Comma);
245            self.a.unparse_tokens(tokens);
246            tokens.push(PtxToken::Comma);
247            self.b.unparse_tokens(tokens);
248            tokens.push(PtxToken::Comma);
249            self.c.unparse_tokens(tokens);
250            tokens.push(PtxToken::Semicolon);
251        }
252    }
253
254    impl PtxUnparser for FmaRndReluBf16x2 {
255        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
256            push_opcode(tokens, "fma");
257            match &self.rnd {
258                Rnd::Rn => {
259                    push_directive(tokens, "rn");
260                }
261            }
262            if self.relu {
263                push_directive(tokens, "relu");
264            }
265            push_directive(tokens, "bf16x2");
266            self.d.unparse_tokens(tokens);
267            tokens.push(PtxToken::Comma);
268            self.a.unparse_tokens(tokens);
269            tokens.push(PtxToken::Comma);
270            self.b.unparse_tokens(tokens);
271            tokens.push(PtxToken::Comma);
272            self.c.unparse_tokens(tokens);
273            tokens.push(PtxToken::Semicolon);
274        }
275    }
276
277    impl PtxUnparser for FmaRndOobReluType {
278        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
279            push_opcode(tokens, "fma");
280            match &self.rnd {
281                Rnd::Rn => {
282                    push_directive(tokens, "rn");
283                }
284            }
285            push_directive(tokens, "oob");
286            if self.relu {
287                push_directive(tokens, "relu");
288            }
289            push_directive(tokens, "type");
290            self.d.unparse_tokens(tokens);
291            tokens.push(PtxToken::Comma);
292            self.a.unparse_tokens(tokens);
293            tokens.push(PtxToken::Comma);
294            self.b.unparse_tokens(tokens);
295            tokens.push(PtxToken::Comma);
296            self.c.unparse_tokens(tokens);
297            tokens.push(PtxToken::Semicolon);
298        }
299    }
300}
301
302pub mod section_2 {
303    use super::*;
304    use crate::r#type::instruction::fma::section_2::*;
305
306    impl PtxUnparser for FmaRndSatF32Abtype {
307        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
308            push_opcode(tokens, "fma");
309            match &self.rnd {
310                Rnd::Rn => {
311                    push_directive(tokens, "rn");
312                }
313                Rnd::Rz => {
314                    push_directive(tokens, "rz");
315                }
316                Rnd::Rm => {
317                    push_directive(tokens, "rm");
318                }
319                Rnd::Rp => {
320                    push_directive(tokens, "rp");
321                }
322            }
323            if self.sat {
324                push_directive(tokens, "sat");
325            }
326            push_directive(tokens, "f32");
327            match &self.abtype {
328                Abtype::Bf16 => {
329                    push_directive(tokens, "bf16");
330                }
331                Abtype::F16 => {
332                    push_directive(tokens, "f16");
333                }
334            }
335            self.d.unparse_tokens(tokens);
336            tokens.push(PtxToken::Comma);
337            self.a.unparse_tokens(tokens);
338            tokens.push(PtxToken::Comma);
339            self.b.unparse_tokens(tokens);
340            tokens.push(PtxToken::Comma);
341            self.c.unparse_tokens(tokens);
342            tokens.push(PtxToken::Semicolon);
343        }
344    }
345}
ptx_parser/unparser/instruction/fma.rs

ptx_parser/unparser/instruction/
fma.rs
