ptx_parser/unparser/instruction/
max.rs

1//! Original PTX specification:
2//!
3//! max.atype         d, a, b;
4//! max{.relu}.btype  d, a, b;
5//! .atype = { .u16, .u32, .u64,
6//! .u16x2, .s16, .s64 };
7//! .btype = { .s16x2, .s32 };
8//! 
9//! max{.ftz}{.NaN}{.xorsign.abs}.f32  d, a, b;
10//! max{.ftz}{.NaN}{.abs}.f32          d, a, b, c;
11//! max.f64                            d, a, b;
12//! 
13//! max{.ftz}{.NaN}{.xorsign.abs}.f16      d, a, b;
14//! max{.ftz}{.NaN}{.xorsign.abs}.f16x2    d, a, b;
15//! max{.NaN}{.xorsign.abs}.bf16           d, a, b;
16//! max{.NaN}{.xorsign.abs}.bf16x2         d, a, b;
17
18#![allow(unused)]
19
20use crate::lexer::PtxToken;
21use crate::unparser::{PtxUnparser, common::*};
22
23pub mod section_0 {
24    use super::*;
25    use crate::r#type::instruction::max::section_0::*;
26
27    impl PtxUnparser for MaxAtype {
28        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
29            push_opcode(tokens, "max");
30                    match &self.atype {
31                            Atype::U16x2 => {
32                                    push_directive(tokens, "u16x2");
33                            }
34                            Atype::U16 => {
35                                    push_directive(tokens, "u16");
36                            }
37                            Atype::U32 => {
38                                    push_directive(tokens, "u32");
39                            }
40                            Atype::U64 => {
41                                    push_directive(tokens, "u64");
42                            }
43                            Atype::S16 => {
44                                    push_directive(tokens, "s16");
45                            }
46                            Atype::S64 => {
47                                    push_directive(tokens, "s64");
48                            }
49                    }
50                    self.d.unparse_tokens(tokens);
51            tokens.push(PtxToken::Comma);
52                    self.a.unparse_tokens(tokens);
53            tokens.push(PtxToken::Comma);
54                    self.b.unparse_tokens(tokens);
55            tokens.push(PtxToken::Semicolon);
56        }
57    }
58
59    impl PtxUnparser for MaxReluBtype {
60        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
61            push_opcode(tokens, "max");
62                    if self.relu {
63                            push_directive(tokens, "relu");
64                    }
65                    match &self.btype {
66                            Btype::S16x2 => {
67                                    push_directive(tokens, "s16x2");
68                            }
69                            Btype::S32 => {
70                                    push_directive(tokens, "s32");
71                            }
72                    }
73                    self.d.unparse_tokens(tokens);
74            tokens.push(PtxToken::Comma);
75                    self.a.unparse_tokens(tokens);
76            tokens.push(PtxToken::Comma);
77                    self.b.unparse_tokens(tokens);
78            tokens.push(PtxToken::Semicolon);
79        }
80    }
81
82    impl PtxUnparser for MaxFtzNanXorsignAbsF32 {
83        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
84            push_opcode(tokens, "max");
85                    if self.ftz {
86                            push_directive(tokens, "ftz");
87                    }
88                    if self.nan {
89                            push_directive(tokens, "NaN");
90                    }
91                    if self.xorsign_abs {
92                            push_directive(tokens, "xorsign.abs");
93                    }
94                    push_directive(tokens, "f32");
95                    self.d.unparse_tokens(tokens);
96            tokens.push(PtxToken::Comma);
97                    self.a.unparse_tokens(tokens);
98            tokens.push(PtxToken::Comma);
99                    self.b.unparse_tokens(tokens);
100            tokens.push(PtxToken::Semicolon);
101        }
102    }
103
104    impl PtxUnparser for MaxFtzNanAbsF32 {
105        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
106            push_opcode(tokens, "max");
107                    if self.ftz {
108                            push_directive(tokens, "ftz");
109                    }
110                    if self.nan {
111                            push_directive(tokens, "NaN");
112                    }
113                    if self.abs {
114                            push_directive(tokens, "abs");
115                    }
116                    push_directive(tokens, "f32");
117                    self.d.unparse_tokens(tokens);
118            tokens.push(PtxToken::Comma);
119                    self.a.unparse_tokens(tokens);
120            tokens.push(PtxToken::Comma);
121                    self.b.unparse_tokens(tokens);
122            tokens.push(PtxToken::Comma);
123                    self.c.unparse_tokens(tokens);
124            tokens.push(PtxToken::Semicolon);
125        }
126    }
127
128    impl PtxUnparser for MaxF64 {
129        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
130            push_opcode(tokens, "max");
131                    push_directive(tokens, "f64");
132                    self.d.unparse_tokens(tokens);
133            tokens.push(PtxToken::Comma);
134                    self.a.unparse_tokens(tokens);
135            tokens.push(PtxToken::Comma);
136                    self.b.unparse_tokens(tokens);
137            tokens.push(PtxToken::Semicolon);
138        }
139    }
140
141    impl PtxUnparser for MaxFtzNanXorsignAbsF16 {
142        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
143            push_opcode(tokens, "max");
144                    if self.ftz {
145                            push_directive(tokens, "ftz");
146                    }
147                    if self.nan {
148                            push_directive(tokens, "NaN");
149                    }
150                    if self.xorsign_abs {
151                            push_directive(tokens, "xorsign.abs");
152                    }
153                    push_directive(tokens, "f16");
154                    self.d.unparse_tokens(tokens);
155            tokens.push(PtxToken::Comma);
156                    self.a.unparse_tokens(tokens);
157            tokens.push(PtxToken::Comma);
158                    self.b.unparse_tokens(tokens);
159            tokens.push(PtxToken::Semicolon);
160        }
161    }
162
163    impl PtxUnparser for MaxFtzNanXorsignAbsF16x2 {
164        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
165            push_opcode(tokens, "max");
166                    if self.ftz {
167                            push_directive(tokens, "ftz");
168                    }
169                    if self.nan {
170                            push_directive(tokens, "NaN");
171                    }
172                    if self.xorsign_abs {
173                            push_directive(tokens, "xorsign.abs");
174                    }
175                    push_directive(tokens, "f16x2");
176                    self.d.unparse_tokens(tokens);
177            tokens.push(PtxToken::Comma);
178                    self.a.unparse_tokens(tokens);
179            tokens.push(PtxToken::Comma);
180                    self.b.unparse_tokens(tokens);
181            tokens.push(PtxToken::Semicolon);
182        }
183    }
184
185    impl PtxUnparser for MaxNanXorsignAbsBf16 {
186        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
187            push_opcode(tokens, "max");
188                    if self.nan {
189                            push_directive(tokens, "NaN");
190                    }
191                    if self.xorsign_abs {
192                            push_directive(tokens, "xorsign.abs");
193                    }
194                    push_directive(tokens, "bf16");
195                    self.d.unparse_tokens(tokens);
196            tokens.push(PtxToken::Comma);
197                    self.a.unparse_tokens(tokens);
198            tokens.push(PtxToken::Comma);
199                    self.b.unparse_tokens(tokens);
200            tokens.push(PtxToken::Semicolon);
201        }
202    }
203
204    impl PtxUnparser for MaxNanXorsignAbsBf16x2 {
205        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
206            push_opcode(tokens, "max");
207                    if self.nan {
208                            push_directive(tokens, "NaN");
209                    }
210                    if self.xorsign_abs {
211                            push_directive(tokens, "xorsign.abs");
212                    }
213                    push_directive(tokens, "bf16x2");
214                    self.d.unparse_tokens(tokens);
215            tokens.push(PtxToken::Comma);
216                    self.a.unparse_tokens(tokens);
217            tokens.push(PtxToken::Comma);
218                    self.b.unparse_tokens(tokens);
219            tokens.push(PtxToken::Semicolon);
220        }
221    }
222
223}
224
ptx_parser/unparser/instruction/max.rs

ptx_parser/unparser/instruction/
max.rs
