1use crate::r#type::common::*;
4use super::{TreeDisplay, TreeFormatter};
5
6impl TreeDisplay for CodeLinkage {
7 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
8 let (variant, span) = match self {
9 CodeLinkage::Visible { span } => ("Visible", span),
10 CodeLinkage::Extern { span } => ("Extern", span),
11 CodeLinkage::Weak { span } => ("Weak", span),
12 };
13 f.root(&format!("CodeLinkage::{} [{}]", variant, f.format_raw(*span, source)))
14 }
15}
16
17impl TreeDisplay for DataLinkage {
18 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
19 let (variant, span) = match self {
20 DataLinkage::Visible { span } => ("Visible", span),
21 DataLinkage::Extern { span } => ("Extern", span),
22 DataLinkage::Weak { span } => ("Weak", span),
23 DataLinkage::Common { span } => ("Common", span),
24 };
25 f.root(&format!("DataLinkage::{} [{}]", variant, f.format_raw(*span, source)))
26 }
27}
28
29impl TreeDisplay for AttributeDirective {
30 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
31 match self {
32 AttributeDirective::Unified { uuid1, uuid2, span } => {
33 f.root(&format!("AttributeDirective::Unified [{}]", f.format_raw(*span, source)))?;
34 f.field(false, "uuid1", &uuid1.to_string())?;
35 f.field(true, "uuid2", &uuid2.to_string())
36 }
37 AttributeDirective::Managed { span } => {
38 f.root(&format!("AttributeDirective::Managed [{}]", f.format_raw(*span, source)))
39 }
40 }
41 }
42}
43
44impl TreeDisplay for DataType {
45 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
46 let (variant, span) = match self {
47 DataType::U8 { span } => ("U8", span),
48 DataType::U16 { span } => ("U16", span),
49 DataType::U32 { span } => ("U32", span),
50 DataType::U64 { span } => ("U64", span),
51 DataType::S8 { span } => ("S8", span),
52 DataType::S16 { span } => ("S16", span),
53 DataType::S32 { span } => ("S32", span),
54 DataType::S64 { span } => ("S64", span),
55 DataType::F16 { span } => ("F16", span),
56 DataType::F16x2 { span } => ("F16x2", span),
57 DataType::F32 { span } => ("F32", span),
58 DataType::F64 { span } => ("F64", span),
59 DataType::B8 { span } => ("B8", span),
60 DataType::B16 { span } => ("B16", span),
61 DataType::B32 { span } => ("B32", span),
62 DataType::B64 { span } => ("B64", span),
63 DataType::B128 { span } => ("B128", span),
64 DataType::Pred { span } => ("Pred", span),
65 DataType::TexRef { span } => ("TexRef", span),
66 DataType::SamplerRef { span } => ("SamplerRef", span),
67 DataType::SurfRef { span } => ("SurfRef", span),
68 };
69 f.root(&format!("DataType::{} [{}]", variant, f.format_raw(*span, source)))
70 }
71}
72
73impl TreeDisplay for Sign {
74 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
75 let (variant, span) = match self {
76 Sign::Negative { span } => ("Negative", span),
77 Sign::Positive { span } => ("Positive", span),
78 };
79 f.root(&format!("Sign::{} [{}]", variant, f.format_raw(*span, source)))
80 }
81}
82
83impl TreeDisplay for Axis {
84 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
85 let (variant, span) = match self {
86 Axis::None { span } => ("None", span),
87 Axis::X { span } => ("X", span),
88 Axis::Y { span } => ("Y", span),
89 Axis::Z { span } => ("Z", span),
90 };
91 f.root(&format!("Axis::{} [{}]", variant, f.format_raw(*span, source)))
92 }
93}
94
95impl TreeDisplay for SpecialRegister {
96 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
97 match self {
98 SpecialRegister::AggrSmemSize { span } => {
99 f.root(&format!("SpecialRegister::AggrSmemSize [{}]", f.format_raw(*span, source)))
100 }
101 SpecialRegister::DynamicSmemSize { span } => {
102 f.root(&format!("SpecialRegister::DynamicSmemSize [{}]", f.format_raw(*span, source)))
103 }
104 SpecialRegister::LanemaskGt { span } => {
105 f.root(&format!("SpecialRegister::LanemaskGt [{}]", f.format_raw(*span, source)))
106 }
107 SpecialRegister::ReservedSmemOffsetBegin { span } => {
108 f.root(&format!("SpecialRegister::ReservedSmemOffsetBegin [{}]", f.format_raw(*span, source)))
109 }
110 SpecialRegister::Clock { span } => {
111 f.root(&format!("SpecialRegister::Clock [{}]", f.format_raw(*span, source)))
112 }
113 SpecialRegister::Envreg { index, span } => {
114 f.root(&format!("SpecialRegister::Envreg [{}]", f.format_raw(*span, source)))?;
115 f.field(true, "index", &index.to_string())
116 }
117 SpecialRegister::LanemaskLe { span } => {
118 f.root(&format!("SpecialRegister::LanemaskLe [{}]", f.format_raw(*span, source)))
119 }
120 SpecialRegister::ReservedSmemOffsetCap { span } => {
121 f.root(&format!("SpecialRegister::ReservedSmemOffsetCap [{}]", f.format_raw(*span, source)))
122 }
123 SpecialRegister::Clock64 { span } => {
124 f.root(&format!("SpecialRegister::Clock64 [{}]", f.format_raw(*span, source)))
125 }
126 SpecialRegister::Globaltimer { span } => {
127 f.root(&format!("SpecialRegister::Globaltimer [{}]", f.format_raw(*span, source)))
128 }
129 SpecialRegister::LanemaskLt { span } => {
130 f.root(&format!("SpecialRegister::LanemaskLt [{}]", f.format_raw(*span, source)))
131 }
132 SpecialRegister::ReservedSmemOffsetEnd { span } => {
133 f.root(&format!("SpecialRegister::ReservedSmemOffsetEnd [{}]", f.format_raw(*span, source)))
134 }
135 SpecialRegister::ClusterCtaid { axis, span } => {
136 f.root(&format!("SpecialRegister::ClusterCtaid [{}]", f.format_raw(*span, source)))?;
137 f.field_with_child(true, "axis", axis, source)
138 }
139 SpecialRegister::GlobaltimerHi { span } => {
140 f.root(&format!("SpecialRegister::GlobaltimerHi [{}]", f.format_raw(*span, source)))
141 }
142 SpecialRegister::Nclusterid { span } => {
143 f.root(&format!("SpecialRegister::Nclusterid [{}]", f.format_raw(*span, source)))
144 }
145 SpecialRegister::Smid { span } => {
146 f.root(&format!("SpecialRegister::Smid [{}]", f.format_raw(*span, source)))
147 }
148 SpecialRegister::ClusterCtarank { axis, span } => {
149 f.root(&format!("SpecialRegister::ClusterCtarank [{}]", f.format_raw(*span, source)))?;
150 f.field_with_child(true, "axis", axis, source)
151 }
152 SpecialRegister::GlobaltimerLo { span } => {
153 f.root(&format!("SpecialRegister::GlobaltimerLo [{}]", f.format_raw(*span, source)))
154 }
155 SpecialRegister::Nctaid { axis, span } => {
156 f.root(&format!("SpecialRegister::Nctaid [{}]", f.format_raw(*span, source)))?;
157 f.field_with_child(true, "axis", axis, source)
158 }
159 SpecialRegister::Tid { axis, span } => {
160 f.root(&format!("SpecialRegister::Tid [{}]", f.format_raw(*span, source)))?;
161 f.field_with_child(true, "axis", axis, source)
162 }
163 SpecialRegister::ClusterNctaid { axis, span } => {
164 f.root(&format!("SpecialRegister::ClusterNctaid [{}]", f.format_raw(*span, source)))?;
165 f.field_with_child(true, "axis", axis, source)
166 }
167 SpecialRegister::Gridid { span } => {
168 f.root(&format!("SpecialRegister::Gridid [{}]", f.format_raw(*span, source)))
169 }
170 SpecialRegister::Nsmid { span } => {
171 f.root(&format!("SpecialRegister::Nsmid [{}]", f.format_raw(*span, source)))
172 }
173 SpecialRegister::TotalSmemSize { span } => {
174 f.root(&format!("SpecialRegister::TotalSmemSize [{}]", f.format_raw(*span, source)))
175 }
176 SpecialRegister::ClusterNctarank { axis, span } => {
177 f.root(&format!("SpecialRegister::ClusterNctarank [{}]", f.format_raw(*span, source)))?;
178 f.field_with_child(true, "axis", axis, source)
179 }
180 SpecialRegister::IsExplicitCluster { span } => {
181 f.root(&format!("SpecialRegister::IsExplicitCluster [{}]", f.format_raw(*span, source)))
182 }
183 SpecialRegister::Ntid { axis, span } => {
184 f.root(&format!("SpecialRegister::Ntid [{}]", f.format_raw(*span, source)))?;
185 f.field_with_child(true, "axis", axis, source)
186 }
187 SpecialRegister::Warpid { span } => {
188 f.root(&format!("SpecialRegister::Warpid [{}]", f.format_raw(*span, source)))
189 }
190 SpecialRegister::Clusterid { span } => {
191 f.root(&format!("SpecialRegister::Clusterid [{}]", f.format_raw(*span, source)))
192 }
193 SpecialRegister::Laneid { span } => {
194 f.root(&format!("SpecialRegister::Laneid [{}]", f.format_raw(*span, source)))
195 }
196 SpecialRegister::Nwarpid { span } => {
197 f.root(&format!("SpecialRegister::Nwarpid [{}]", f.format_raw(*span, source)))
198 }
199 SpecialRegister::WARPSZ { span } => {
200 f.root(&format!("SpecialRegister::WARPSZ [{}]", f.format_raw(*span, source)))
201 }
202 SpecialRegister::Ctaid { axis, span } => {
203 f.root(&format!("SpecialRegister::Ctaid [{}]", f.format_raw(*span, source)))?;
204 f.field_with_child(true, "axis", axis, source)
205 }
206 SpecialRegister::LanemaskEq { span } => {
207 f.root(&format!("SpecialRegister::LanemaskEq [{}]", f.format_raw(*span, source)))
208 }
209 SpecialRegister::Pm { index, span } => {
210 f.root(&format!("SpecialRegister::Pm [{}]", f.format_raw(*span, source)))?;
211 f.field(true, "index", &index.to_string())
212 }
213 SpecialRegister::Pm64 { index, span } => {
214 f.root(&format!("SpecialRegister::Pm64 [{}]", f.format_raw(*span, source)))?;
215 f.field(true, "index", &index.to_string())
216 }
217 SpecialRegister::CurrentGraphExec { span } => {
218 f.root(&format!("SpecialRegister::CurrentGraphExec [{}]", f.format_raw(*span, source)))
219 }
220 SpecialRegister::LanemaskGe { span } => {
221 f.root(&format!("SpecialRegister::LanemaskGe [{}]", f.format_raw(*span, source)))
222 }
223 SpecialRegister::ReservedSmemOffset { index, span } => {
224 f.root(&format!("SpecialRegister::ReservedSmemOffset [{}]", f.format_raw(*span, source)))?;
225 f.field(true, "index", &index.to_string())
226 }
227 }
228 }
229}
230
231impl TreeDisplay for Label {
232 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
233 f.root(&format!("Label [{}]", f.format_raw(self.span, source)))?;
234 f.field(true, "val", &self.val)
235 }
236}
237
238impl TreeDisplay for Predicate {
239 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
240 f.root(&format!("Predicate [{}]", f.format_raw(self.span, source)))?;
241 f.field(false, "negated", &self.negated.to_string())?;
242 f.field_with_child(true, "operand", &self.operand, source)
243 }
244}
245
246impl TreeDisplay for Instruction {
247 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
248 let pred_str = match &self.predicate {
249 Some(p) => format!("@{}{} ", if p.negated { "!" } else { "" }, format!("{:?}", p.operand)),
250 None => String::new(),
251 };
252 f.root(&format!("Instruction [{}] {}{:?}", f.format_raw(self.span, source), pred_str, self.inst))
253 }
254}
255
256impl TreeDisplay for Operand {
257 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
258 match self {
259 Operand::Register { operand, span } => {
260 f.root(&format!("Operand::Register [{}]", f.format_raw(*span, source)))?;
261 f.field_with_child(true, "operand", operand, source)
262 }
263 Operand::Immediate { operand, span } => {
264 f.root(&format!("Operand::Immediate [{}]", f.format_raw(*span, source)))?;
265 f.field_with_child(true, "operand", operand, source)
266 }
267 Operand::Symbol { name, span } => {
268 f.root(&format!("Operand::Symbol [{}]", f.format_raw(*span, source)))?;
269 f.field(true, "name", name)
270 }
271 Operand::SymbolOffset { symbol, offset, span } => {
272 f.root(&format!("Operand::SymbolOffset [{}]", f.format_raw(*span, source)))?;
273 f.field(false, "symbol", symbol)?;
274 f.field_with_child(true, "offset", offset, source)
275 }
276 }
277 }
278}
279
280impl TreeDisplay for RegisterOperand {
281 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
282 f.root(&format!("RegisterOperand [{}]", f.format_raw(self.span, source)))?;
283 f.field(false, "name", &self.name)?;
284 match &self.component {
285 Some(c) => f.field(true, "component", &format!("Some({})", c)),
286 None => f.field(true, "component", "None"),
287 }
288 }
289}
290
291impl TreeDisplay for Immediate {
292 fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
293 f.root(&format!("Immediate [{}]", f.format_raw(self.span, source)))?;
294 f.field(true, "value", &self.value)
295 }
296}