ptx_parser/unparser/instruction/
div.rs

1//! Original PTX specification:
2//!
3//! div.type  d, a, b;
4//! .type = { .u16, .u32, .u64,
5//! .s16, .s32, .s64 };
6//!
7//! div.approx{.ftz}.f32  d, a, b;  // fast, approximate divide
8//! div.full{.ftz}.f32    d, a, b;  // full-range approximate divide
9//! div.rnd{.ftz}.f32     d, a, b;  // IEEE 754 compliant rounding
10//! div.rnd.f64           d, a, b;  // IEEE 754 compliant rounding
11//! .rnd = { .rn, .rz, .rm, .rp };
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::div::section_0::*;
21
22    impl PtxUnparser for DivType {
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, "div");
28            match &self.type_ {
29                Type::U16 => {
30                    push_directive(tokens, "u16");
31                }
32                Type::U32 => {
33                    push_directive(tokens, "u32");
34                }
35                Type::U64 => {
36                    push_directive(tokens, "u64");
37                }
38                Type::S16 => {
39                    push_directive(tokens, "s16");
40                }
41                Type::S32 => {
42                    push_directive(tokens, "s32");
43                }
44                Type::S64 => {
45                    push_directive(tokens, "s64");
46                }
47            }
48            if spaced {
49                tokens.push(PtxToken::Space);
50            }
51            self.d.unparse_tokens_mode(tokens, spaced);
52            tokens.push(PtxToken::Comma);
53            if spaced {
54                tokens.push(PtxToken::Space);
55            }
56            self.a.unparse_tokens_mode(tokens, spaced);
57            tokens.push(PtxToken::Comma);
58            if spaced {
59                tokens.push(PtxToken::Space);
60            }
61            self.b.unparse_tokens_mode(tokens, spaced);
62            tokens.push(PtxToken::Semicolon);
63            if spaced {
64                tokens.push(PtxToken::Newline);
65            }
66        }
67    }
68
69    impl PtxUnparser for DivApproxFtzF32 {
70        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
71            self.unparse_tokens_mode(tokens, false);
72        }
73        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
74            push_opcode(tokens, "div");
75            push_directive(tokens, "approx");
76            if self.ftz {
77                push_directive(tokens, "ftz");
78            }
79            push_directive(tokens, "f32");
80            if spaced {
81                tokens.push(PtxToken::Space);
82            }
83            self.d.unparse_tokens_mode(tokens, spaced);
84            tokens.push(PtxToken::Comma);
85            if spaced {
86                tokens.push(PtxToken::Space);
87            }
88            self.a.unparse_tokens_mode(tokens, spaced);
89            tokens.push(PtxToken::Comma);
90            if spaced {
91                tokens.push(PtxToken::Space);
92            }
93            self.b.unparse_tokens_mode(tokens, spaced);
94            tokens.push(PtxToken::Semicolon);
95            if spaced {
96                tokens.push(PtxToken::Newline);
97            }
98        }
99    }
100
101    impl PtxUnparser for DivFullFtzF32 {
102        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
103            self.unparse_tokens_mode(tokens, false);
104        }
105        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
106            push_opcode(tokens, "div");
107            push_directive(tokens, "full");
108            if self.ftz {
109                push_directive(tokens, "ftz");
110            }
111            push_directive(tokens, "f32");
112            if spaced {
113                tokens.push(PtxToken::Space);
114            }
115            self.d.unparse_tokens_mode(tokens, spaced);
116            tokens.push(PtxToken::Comma);
117            if spaced {
118                tokens.push(PtxToken::Space);
119            }
120            self.a.unparse_tokens_mode(tokens, spaced);
121            tokens.push(PtxToken::Comma);
122            if spaced {
123                tokens.push(PtxToken::Space);
124            }
125            self.b.unparse_tokens_mode(tokens, spaced);
126            tokens.push(PtxToken::Semicolon);
127            if spaced {
128                tokens.push(PtxToken::Newline);
129            }
130        }
131    }
132
133    impl PtxUnparser for DivRndFtzF32 {
134        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
135            self.unparse_tokens_mode(tokens, false);
136        }
137        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
138            push_opcode(tokens, "div");
139            match &self.rnd {
140                Rnd::Rn => {
141                    push_directive(tokens, "rn");
142                }
143                Rnd::Rz => {
144                    push_directive(tokens, "rz");
145                }
146                Rnd::Rm => {
147                    push_directive(tokens, "rm");
148                }
149                Rnd::Rp => {
150                    push_directive(tokens, "rp");
151                }
152            }
153            if self.ftz {
154                push_directive(tokens, "ftz");
155            }
156            push_directive(tokens, "f32");
157            if spaced {
158                tokens.push(PtxToken::Space);
159            }
160            self.d.unparse_tokens_mode(tokens, spaced);
161            tokens.push(PtxToken::Comma);
162            if spaced {
163                tokens.push(PtxToken::Space);
164            }
165            self.a.unparse_tokens_mode(tokens, spaced);
166            tokens.push(PtxToken::Comma);
167            if spaced {
168                tokens.push(PtxToken::Space);
169            }
170            self.b.unparse_tokens_mode(tokens, spaced);
171            tokens.push(PtxToken::Semicolon);
172            if spaced {
173                tokens.push(PtxToken::Newline);
174            }
175        }
176    }
177
178    impl PtxUnparser for DivRndF64 {
179        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
180            self.unparse_tokens_mode(tokens, false);
181        }
182        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
183            push_opcode(tokens, "div");
184            match &self.rnd {
185                Rnd::Rn => {
186                    push_directive(tokens, "rn");
187                }
188                Rnd::Rz => {
189                    push_directive(tokens, "rz");
190                }
191                Rnd::Rm => {
192                    push_directive(tokens, "rm");
193                }
194                Rnd::Rp => {
195                    push_directive(tokens, "rp");
196                }
197            }
198            push_directive(tokens, "f64");
199            if spaced {
200                tokens.push(PtxToken::Space);
201            }
202            self.d.unparse_tokens_mode(tokens, spaced);
203            tokens.push(PtxToken::Comma);
204            if spaced {
205                tokens.push(PtxToken::Space);
206            }
207            self.a.unparse_tokens_mode(tokens, spaced);
208            tokens.push(PtxToken::Comma);
209            if spaced {
210                tokens.push(PtxToken::Space);
211            }
212            self.b.unparse_tokens_mode(tokens, spaced);
213            tokens.push(PtxToken::Semicolon);
214            if spaced {
215                tokens.push(PtxToken::Newline);
216            }
217        }
218    }
219}
ptx_parser/unparser/instruction/div.rs

ptx_parser/unparser/instruction/
div.rs
