use super::{TreeDisplay, TreeFormatter};
use crate::r#type::common::*;
impl TreeDisplay for CodeLinkage {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let (variant, span) = match self {
CodeLinkage::Visible { span } => ("Visible", span),
CodeLinkage::Extern { span } => ("Extern", span),
CodeLinkage::Weak { span } => ("Weak", span),
};
f.root(&format!(
"CodeLinkage::{} [{}]",
variant,
f.format_raw(*span, source)
))
}
}
impl TreeDisplay for DataLinkage {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let (variant, span) = match self {
DataLinkage::Visible { span } => ("Visible", span),
DataLinkage::Extern { span } => ("Extern", span),
DataLinkage::Weak { span } => ("Weak", span),
DataLinkage::Common { span } => ("Common", span),
};
f.root(&format!(
"DataLinkage::{} [{}]",
variant,
f.format_raw(*span, source)
))
}
}
impl TreeDisplay for AttributeDirective {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
match self {
AttributeDirective::Unified { uuid1, uuid2, span } => {
f.root(&format!(
"AttributeDirective::Unified [{}]",
f.format_raw(*span, source)
))?;
f.field(false, "uuid1", &uuid1.to_string())?;
f.field(true, "uuid2", &uuid2.to_string())
}
AttributeDirective::Managed { span } => f.root(&format!(
"AttributeDirective::Managed [{}]",
f.format_raw(*span, source)
)),
}
}
}
impl TreeDisplay for DataType {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let (variant, span) = match self {
DataType::U8 { span } => ("U8", span),
DataType::U16 { span } => ("U16", span),
DataType::U32 { span } => ("U32", span),
DataType::U64 { span } => ("U64", span),
DataType::S8 { span } => ("S8", span),
DataType::S16 { span } => ("S16", span),
DataType::S32 { span } => ("S32", span),
DataType::S64 { span } => ("S64", span),
DataType::F16 { span } => ("F16", span),
DataType::F16x2 { span } => ("F16x2", span),
DataType::F32 { span } => ("F32", span),
DataType::F64 { span } => ("F64", span),
DataType::B8 { span } => ("B8", span),
DataType::B16 { span } => ("B16", span),
DataType::B32 { span } => ("B32", span),
DataType::B64 { span } => ("B64", span),
DataType::B128 { span } => ("B128", span),
DataType::Pred { span } => ("Pred", span),
DataType::TexRef { span } => ("TexRef", span),
DataType::SamplerRef { span } => ("SamplerRef", span),
DataType::SurfRef { span } => ("SurfRef", span),
};
f.root(&format!(
"DataType::{} [{}]",
variant,
f.format_raw(*span, source)
))
}
}
impl TreeDisplay for Sign {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let (variant, span) = match self {
Sign::Negative { span } => ("Negative", span),
Sign::Positive { span } => ("Positive", span),
};
f.root(&format!(
"Sign::{} [{}]",
variant,
f.format_raw(*span, source)
))
}
}
impl TreeDisplay for Axis {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let (variant, span) = match self {
Axis::None { span } => ("None", span),
Axis::X { span } => ("X", span),
Axis::Y { span } => ("Y", span),
Axis::Z { span } => ("Z", span),
};
f.root(&format!(
"Axis::{} [{}]",
variant,
f.format_raw(*span, source)
))
}
}
impl TreeDisplay for SpecialRegister {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
match self {
SpecialRegister::AggrSmemSize { span } => f.root(&format!(
"SpecialRegister::AggrSmemSize [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::DynamicSmemSize { span } => f.root(&format!(
"SpecialRegister::DynamicSmemSize [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::LanemaskGt { span } => f.root(&format!(
"SpecialRegister::LanemaskGt [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ReservedSmemOffsetBegin { span } => f.root(&format!(
"SpecialRegister::ReservedSmemOffsetBegin [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Clock { span } => f.root(&format!(
"SpecialRegister::Clock [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Envreg { index, span } => {
f.root(&format!(
"SpecialRegister::Envreg [{}]",
f.format_raw(*span, source)
))?;
f.field(true, "index", &index.to_string())
}
SpecialRegister::LanemaskLe { span } => f.root(&format!(
"SpecialRegister::LanemaskLe [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ReservedSmemOffsetCap { span } => f.root(&format!(
"SpecialRegister::ReservedSmemOffsetCap [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Clock64 { span } => f.root(&format!(
"SpecialRegister::Clock64 [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Globaltimer { span } => f.root(&format!(
"SpecialRegister::Globaltimer [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::LanemaskLt { span } => f.root(&format!(
"SpecialRegister::LanemaskLt [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ReservedSmemOffsetEnd { span } => f.root(&format!(
"SpecialRegister::ReservedSmemOffsetEnd [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ClusterCtaid { axis, span } => {
f.root(&format!(
"SpecialRegister::ClusterCtaid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::GlobaltimerHi { span } => f.root(&format!(
"SpecialRegister::GlobaltimerHi [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Nclusterid { span } => f.root(&format!(
"SpecialRegister::Nclusterid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Smid { span } => f.root(&format!(
"SpecialRegister::Smid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ClusterCtarank { axis, span } => {
f.root(&format!(
"SpecialRegister::ClusterCtarank [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::GlobaltimerLo { span } => f.root(&format!(
"SpecialRegister::GlobaltimerLo [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Nctaid { axis, span } => {
f.root(&format!(
"SpecialRegister::Nctaid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::Tid { axis, span } => {
f.root(&format!(
"SpecialRegister::Tid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::ClusterNctaid { axis, span } => {
f.root(&format!(
"SpecialRegister::ClusterNctaid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::Gridid { span } => f.root(&format!(
"SpecialRegister::Gridid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Nsmid { span } => f.root(&format!(
"SpecialRegister::Nsmid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::TotalSmemSize { span } => f.root(&format!(
"SpecialRegister::TotalSmemSize [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ClusterNctarank { axis, span } => {
f.root(&format!(
"SpecialRegister::ClusterNctarank [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::IsExplicitCluster { span } => f.root(&format!(
"SpecialRegister::IsExplicitCluster [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Ntid { axis, span } => {
f.root(&format!(
"SpecialRegister::Ntid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::Warpid { span } => f.root(&format!(
"SpecialRegister::Warpid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Clusterid { span } => f.root(&format!(
"SpecialRegister::Clusterid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Laneid { span } => f.root(&format!(
"SpecialRegister::Laneid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Nwarpid { span } => f.root(&format!(
"SpecialRegister::Nwarpid [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::WARPSZ { span } => f.root(&format!(
"SpecialRegister::WARPSZ [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Ctaid { axis, span } => {
f.root(&format!(
"SpecialRegister::Ctaid [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "axis", axis, source)
}
SpecialRegister::LanemaskEq { span } => f.root(&format!(
"SpecialRegister::LanemaskEq [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::Pm { index, span } => {
f.root(&format!(
"SpecialRegister::Pm [{}]",
f.format_raw(*span, source)
))?;
f.field(true, "index", &index.to_string())
}
SpecialRegister::Pm64 { index, span } => {
f.root(&format!(
"SpecialRegister::Pm64 [{}]",
f.format_raw(*span, source)
))?;
f.field(true, "index", &index.to_string())
}
SpecialRegister::CurrentGraphExec { span } => f.root(&format!(
"SpecialRegister::CurrentGraphExec [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::LanemaskGe { span } => f.root(&format!(
"SpecialRegister::LanemaskGe [{}]",
f.format_raw(*span, source)
)),
SpecialRegister::ReservedSmemOffset { index, span } => {
f.root(&format!(
"SpecialRegister::ReservedSmemOffset [{}]",
f.format_raw(*span, source)
))?;
f.field(true, "index", &index.to_string())
}
}
}
}
impl TreeDisplay for Label {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
f.root(&format!("Label [{}]", f.format_raw(self.span, source)))?;
f.field(true, "val", &self.val)
}
}
impl TreeDisplay for Predicate {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
f.root(&format!("Predicate [{}]", f.format_raw(self.span, source)))?;
f.field(false, "negated", &self.negated.to_string())?;
f.field_with_child(true, "operand", &self.operand, source)
}
}
impl TreeDisplay for Instruction {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
let pred_str = match &self.predicate {
Some(p) => format!(
"@{}{} ",
if p.negated { "!" } else { "" },
format!("{:?}", p.operand)
),
None => String::new(),
};
f.root(&format!(
"Instruction [{}] {}{:?}",
f.format_raw(self.span, source),
pred_str,
self.inst
))
}
}
impl TreeDisplay for Operand {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
match self {
Operand::Register { operand, span } => {
f.root(&format!(
"Operand::Register [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "operand", operand, source)
}
Operand::Immediate { operand, span } => {
f.root(&format!(
"Operand::Immediate [{}]",
f.format_raw(*span, source)
))?;
f.field_with_child(true, "operand", operand, source)
}
Operand::Symbol { name, span } => {
f.root(&format!(
"Operand::Symbol [{}]",
f.format_raw(*span, source)
))?;
f.field(true, "name", name)
}
Operand::SymbolOffset {
symbol,
offset,
span,
} => {
f.root(&format!(
"Operand::SymbolOffset [{}]",
f.format_raw(*span, source)
))?;
f.field(false, "symbol", symbol)?;
f.field_with_child(true, "offset", offset, source)
}
}
}
}
impl TreeDisplay for RegisterOperand {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
f.root(&format!(
"RegisterOperand [{}]",
f.format_raw(self.span, source)
))?;
f.field(false, "name", &self.name)?;
match &self.component {
Some(c) => f.field(true, "component", &format!("Some({})", c)),
None => f.field(true, "component", "None"),
}
}
}
impl TreeDisplay for Immediate {
fn tree_display(&self, f: &mut TreeFormatter, source: &str) -> std::fmt::Result {
f.root(&format!("Immediate [{}]", f.format_raw(self.span, source)))?;
f.field(true, "value", &self.value)
}
}