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

ptx_parser/unparser/instruction/
min.rs
