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}
ptx_parser/unparser/instruction/max.rs

ptx_parser/unparser/instruction/
max.rs
