ptx_parser/unparser/instruction/
sust.rs

1//! Original PTX specification:
2//!
3//! sust.b.dim{.cop}.vec.ctype{.mode} [a, b], c;  // unformatted
4//! sust.p.dim.vec.b32{.mode}       [a, b], c;  // formatted
5//! sust.b.adim{.cop}.vec.ctype{.mode}   [a, b], c;  // unformatted
6//! .cop   = { .wb, .cg, .cs, .wt };                     // cache operation
7//! .vec   = { none, .v2, .v4 };
8//! .ctype = { .b8 , .b16, .b32, .b64 };
9//! .mode  = { .trap, .clamp, .zero };
10//! .dim   = { .1d, .2d, .3d };
11//! .adim  = { .a1d, .a2d };
12
13#![allow(unused)]
14
15use crate::lexer::PtxToken;
16use crate::unparser::{PtxUnparser, common::*};
17
18pub mod section_0 {
19    use super::*;
20    use crate::r#type::instruction::sust::section_0::*;
21
22    impl PtxUnparser for SustBDimCopVecCtypeMode {
23        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
24            self.unparse_tokens_mode(tokens, false);
25        }
26        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
27            push_opcode(tokens, "sust");
28            push_directive(tokens, "b");
29            match &self.dim {
30                Dim::_1d => {
31                    push_directive(tokens, "1d");
32                }
33                Dim::_2d => {
34                    push_directive(tokens, "2d");
35                }
36                Dim::_3d => {
37                    push_directive(tokens, "3d");
38                }
39            }
40            if let Some(cop_0) = self.cop.as_ref() {
41                match cop_0 {
42                    Cop::Wb => {
43                        push_directive(tokens, "wb");
44                    }
45                    Cop::Cg => {
46                        push_directive(tokens, "cg");
47                    }
48                    Cop::Cs => {
49                        push_directive(tokens, "cs");
50                    }
51                    Cop::Wt => {
52                        push_directive(tokens, "wt");
53                    }
54                }
55            }
56            match &self.vec {
57                Vec::None => {
58                    push_token_from_str(tokens, "none");
59                }
60                Vec::V2 => {
61                    push_directive(tokens, "v2");
62                }
63                Vec::V4 => {
64                    push_directive(tokens, "v4");
65                }
66            }
67            match &self.ctype {
68                Ctype::B16 => {
69                    push_directive(tokens, "b16");
70                }
71                Ctype::B32 => {
72                    push_directive(tokens, "b32");
73                }
74                Ctype::B64 => {
75                    push_directive(tokens, "b64");
76                }
77                Ctype::B8 => {
78                    push_directive(tokens, "b8");
79                }
80            }
81            if let Some(mode_1) = self.mode.as_ref() {
82                match mode_1 {
83                    Mode::Clamp => {
84                        push_directive(tokens, "clamp");
85                    }
86                    Mode::Trap => {
87                        push_directive(tokens, "trap");
88                    }
89                    Mode::Zero => {
90                        push_directive(tokens, "zero");
91                    }
92                }
93            }
94            if spaced {
95                tokens.push(PtxToken::Space);
96            }
97            self.a.unparse_tokens_mode(tokens, spaced);
98            tokens.push(PtxToken::Comma);
99            if spaced {
100                tokens.push(PtxToken::Space);
101            }
102            self.c.unparse_tokens_mode(tokens, spaced);
103            tokens.push(PtxToken::Semicolon);
104            if spaced {
105                tokens.push(PtxToken::Newline);
106            }
107        }
108    }
109
110    impl PtxUnparser for SustPDimVecB32Mode {
111        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
112            self.unparse_tokens_mode(tokens, false);
113        }
114        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
115            push_opcode(tokens, "sust");
116            push_directive(tokens, "p");
117            match &self.dim {
118                Dim::_1d => {
119                    push_directive(tokens, "1d");
120                }
121                Dim::_2d => {
122                    push_directive(tokens, "2d");
123                }
124                Dim::_3d => {
125                    push_directive(tokens, "3d");
126                }
127            }
128            match &self.vec {
129                Vec::None => {
130                    push_token_from_str(tokens, "none");
131                }
132                Vec::V2 => {
133                    push_directive(tokens, "v2");
134                }
135                Vec::V4 => {
136                    push_directive(tokens, "v4");
137                }
138            }
139            push_directive(tokens, "b32");
140            if let Some(mode_2) = self.mode.as_ref() {
141                match mode_2 {
142                    Mode::Clamp => {
143                        push_directive(tokens, "clamp");
144                    }
145                    Mode::Trap => {
146                        push_directive(tokens, "trap");
147                    }
148                    Mode::Zero => {
149                        push_directive(tokens, "zero");
150                    }
151                }
152            }
153            if spaced {
154                tokens.push(PtxToken::Space);
155            }
156            self.a.unparse_tokens_mode(tokens, spaced);
157            tokens.push(PtxToken::Comma);
158            if spaced {
159                tokens.push(PtxToken::Space);
160            }
161            self.c.unparse_tokens_mode(tokens, spaced);
162            tokens.push(PtxToken::Semicolon);
163            if spaced {
164                tokens.push(PtxToken::Newline);
165            }
166        }
167    }
168
169    impl PtxUnparser for SustBAdimCopVecCtypeMode {
170        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
171            self.unparse_tokens_mode(tokens, false);
172        }
173        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
174            push_opcode(tokens, "sust");
175            push_directive(tokens, "b");
176            match &self.adim {
177                Adim::A1d => {
178                    push_directive(tokens, "a1d");
179                }
180                Adim::A2d => {
181                    push_directive(tokens, "a2d");
182                }
183            }
184            if let Some(cop_3) = self.cop.as_ref() {
185                match cop_3 {
186                    Cop::Wb => {
187                        push_directive(tokens, "wb");
188                    }
189                    Cop::Cg => {
190                        push_directive(tokens, "cg");
191                    }
192                    Cop::Cs => {
193                        push_directive(tokens, "cs");
194                    }
195                    Cop::Wt => {
196                        push_directive(tokens, "wt");
197                    }
198                }
199            }
200            match &self.vec {
201                Vec::None => {
202                    push_token_from_str(tokens, "none");
203                }
204                Vec::V2 => {
205                    push_directive(tokens, "v2");
206                }
207                Vec::V4 => {
208                    push_directive(tokens, "v4");
209                }
210            }
211            match &self.ctype {
212                Ctype::B16 => {
213                    push_directive(tokens, "b16");
214                }
215                Ctype::B32 => {
216                    push_directive(tokens, "b32");
217                }
218                Ctype::B64 => {
219                    push_directive(tokens, "b64");
220                }
221                Ctype::B8 => {
222                    push_directive(tokens, "b8");
223                }
224            }
225            if let Some(mode_4) = self.mode.as_ref() {
226                match mode_4 {
227                    Mode::Clamp => {
228                        push_directive(tokens, "clamp");
229                    }
230                    Mode::Trap => {
231                        push_directive(tokens, "trap");
232                    }
233                    Mode::Zero => {
234                        push_directive(tokens, "zero");
235                    }
236                }
237            }
238            if spaced {
239                tokens.push(PtxToken::Space);
240            }
241            self.a.unparse_tokens_mode(tokens, spaced);
242            tokens.push(PtxToken::Comma);
243            if spaced {
244                tokens.push(PtxToken::Space);
245            }
246            self.c.unparse_tokens_mode(tokens, spaced);
247            tokens.push(PtxToken::Semicolon);
248            if spaced {
249                tokens.push(PtxToken::Newline);
250            }
251        }
252    }
253}
ptx_parser/unparser/instruction/sust.rs

ptx_parser/unparser/instruction/
sust.rs
