ptx_parser/unparser/instruction/
mad.rs

1//! Original PTX specification:
2//!
3//! mad.mode.type  d, a, b, c;
4//! mad.hi.sat.s32 d, a, b, c;
5//! .mode = { .hi, .lo, .wide };
6//! .type = { .u16, .u32, .u64,
7//! .s16, .s32, .s64 };
8//!
9//! mad{.ftz}{.sat}.f32      d, a, b, c;    // .target sm_1x
10//! mad.rnd{.ftz}{.sat}.f32  d, a, b, c;    // .target sm_20
11//! mad.rnd.f64              d, a, b, c;    // .target sm_13 and higher
12//! .rnd = { .rn, .rz, .rm, .rp };
13
14#![allow(unused)]
15
16use crate::lexer::PtxToken;
17use crate::unparser::{PtxUnparser, common::*};
18
19pub mod section_0 {
20    use super::*;
21    use crate::r#type::instruction::mad::section_0::*;
22
23    impl PtxUnparser for MadModeType {
24        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
25            self.unparse_tokens_mode(tokens, false);
26        }
27        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
28            push_opcode(tokens, "mad");
29            match &self.mode {
30                Mode::Wide => {
31                    push_directive(tokens, "wide");
32                }
33                Mode::Hi => {
34                    push_directive(tokens, "hi");
35                }
36                Mode::Lo => {
37                    push_directive(tokens, "lo");
38                }
39            }
40            match &self.type_ {
41                Type::U16 => {
42                    push_directive(tokens, "u16");
43                }
44                Type::U32 => {
45                    push_directive(tokens, "u32");
46                }
47                Type::U64 => {
48                    push_directive(tokens, "u64");
49                }
50                Type::S16 => {
51                    push_directive(tokens, "s16");
52                }
53                Type::S32 => {
54                    push_directive(tokens, "s32");
55                }
56                Type::S64 => {
57                    push_directive(tokens, "s64");
58                }
59            }
60            if spaced {
61                tokens.push(PtxToken::Space);
62            }
63            self.d.unparse_tokens_mode(tokens, spaced);
64            tokens.push(PtxToken::Comma);
65            if spaced {
66                tokens.push(PtxToken::Space);
67            }
68            self.a.unparse_tokens_mode(tokens, spaced);
69            tokens.push(PtxToken::Comma);
70            if spaced {
71                tokens.push(PtxToken::Space);
72            }
73            self.b.unparse_tokens_mode(tokens, spaced);
74            tokens.push(PtxToken::Comma);
75            if spaced {
76                tokens.push(PtxToken::Space);
77            }
78            self.c.unparse_tokens_mode(tokens, spaced);
79            tokens.push(PtxToken::Semicolon);
80            if spaced {
81                tokens.push(PtxToken::Newline);
82            }
83        }
84    }
85
86    impl PtxUnparser for MadHiSatS32 {
87        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
88            self.unparse_tokens_mode(tokens, false);
89        }
90        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
91            push_opcode(tokens, "mad");
92            push_directive(tokens, "hi");
93            push_directive(tokens, "sat");
94            push_directive(tokens, "s32");
95            if spaced {
96                tokens.push(PtxToken::Space);
97            }
98            self.d.unparse_tokens_mode(tokens, spaced);
99            tokens.push(PtxToken::Comma);
100            if spaced {
101                tokens.push(PtxToken::Space);
102            }
103            self.a.unparse_tokens_mode(tokens, spaced);
104            tokens.push(PtxToken::Comma);
105            if spaced {
106                tokens.push(PtxToken::Space);
107            }
108            self.b.unparse_tokens_mode(tokens, spaced);
109            tokens.push(PtxToken::Comma);
110            if spaced {
111                tokens.push(PtxToken::Space);
112            }
113            self.c.unparse_tokens_mode(tokens, spaced);
114            tokens.push(PtxToken::Semicolon);
115            if spaced {
116                tokens.push(PtxToken::Newline);
117            }
118        }
119    }
120
121    impl PtxUnparser for MadFtzSatF32 {
122        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
123            self.unparse_tokens_mode(tokens, false);
124        }
125        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
126            push_opcode(tokens, "mad");
127            if self.ftz {
128                push_directive(tokens, "ftz");
129            }
130            if self.sat {
131                push_directive(tokens, "sat");
132            }
133            push_directive(tokens, "f32");
134            if spaced {
135                tokens.push(PtxToken::Space);
136            }
137            self.d.unparse_tokens_mode(tokens, spaced);
138            tokens.push(PtxToken::Comma);
139            if spaced {
140                tokens.push(PtxToken::Space);
141            }
142            self.a.unparse_tokens_mode(tokens, spaced);
143            tokens.push(PtxToken::Comma);
144            if spaced {
145                tokens.push(PtxToken::Space);
146            }
147            self.b.unparse_tokens_mode(tokens, spaced);
148            tokens.push(PtxToken::Comma);
149            if spaced {
150                tokens.push(PtxToken::Space);
151            }
152            self.c.unparse_tokens_mode(tokens, spaced);
153            tokens.push(PtxToken::Semicolon);
154            if spaced {
155                tokens.push(PtxToken::Newline);
156            }
157        }
158    }
159
160    impl PtxUnparser for MadRndFtzSatF32 {
161        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
162            self.unparse_tokens_mode(tokens, false);
163        }
164        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
165            push_opcode(tokens, "mad");
166            match &self.rnd {
167                Rnd::Rn => {
168                    push_directive(tokens, "rn");
169                }
170                Rnd::Rz => {
171                    push_directive(tokens, "rz");
172                }
173                Rnd::Rm => {
174                    push_directive(tokens, "rm");
175                }
176                Rnd::Rp => {
177                    push_directive(tokens, "rp");
178                }
179            }
180            if self.ftz {
181                push_directive(tokens, "ftz");
182            }
183            if self.sat {
184                push_directive(tokens, "sat");
185            }
186            push_directive(tokens, "f32");
187            if spaced {
188                tokens.push(PtxToken::Space);
189            }
190            self.d.unparse_tokens_mode(tokens, spaced);
191            tokens.push(PtxToken::Comma);
192            if spaced {
193                tokens.push(PtxToken::Space);
194            }
195            self.a.unparse_tokens_mode(tokens, spaced);
196            tokens.push(PtxToken::Comma);
197            if spaced {
198                tokens.push(PtxToken::Space);
199            }
200            self.b.unparse_tokens_mode(tokens, spaced);
201            tokens.push(PtxToken::Comma);
202            if spaced {
203                tokens.push(PtxToken::Space);
204            }
205            self.c.unparse_tokens_mode(tokens, spaced);
206            tokens.push(PtxToken::Semicolon);
207            if spaced {
208                tokens.push(PtxToken::Newline);
209            }
210        }
211    }
212
213    impl PtxUnparser for MadRndF64 {
214        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
215            self.unparse_tokens_mode(tokens, false);
216        }
217        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
218            push_opcode(tokens, "mad");
219            match &self.rnd {
220                Rnd::Rn => {
221                    push_directive(tokens, "rn");
222                }
223                Rnd::Rz => {
224                    push_directive(tokens, "rz");
225                }
226                Rnd::Rm => {
227                    push_directive(tokens, "rm");
228                }
229                Rnd::Rp => {
230                    push_directive(tokens, "rp");
231                }
232            }
233            push_directive(tokens, "f64");
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::Comma);
249            if spaced {
250                tokens.push(PtxToken::Space);
251            }
252            self.c.unparse_tokens_mode(tokens, spaced);
253            tokens.push(PtxToken::Semicolon);
254            if spaced {
255                tokens.push(PtxToken::Newline);
256            }
257        }
258    }
259}
ptx_parser/unparser/instruction/mad.rs

ptx_parser/unparser/instruction/
mad.rs
