Skip to main content

oxilean_codegen/spirv_backend/
spirvop_traits.rs

1//! # SpirVOp - Trait Implementations
2//!
3//! This module contains trait implementations for `SpirVOp`.
4//!
5//! ## Implemented Traits
6//!
7//! - `Display`
8//!
9//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
10
11use super::types::{ExecutionMode, MemoryModel, SpirVOp};
12use std::fmt;
13
14impl fmt::Display for SpirVOp {
15    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16        match self {
17            SpirVOp::Variable(sc) => write!(f, "OpVariable({})", sc),
18            SpirVOp::Load => write!(f, "OpLoad"),
19            SpirVOp::Store => write!(f, "OpStore"),
20            SpirVOp::AccessChain => write!(f, "OpAccessChain"),
21            SpirVOp::CopyObject => write!(f, "OpCopyObject"),
22            SpirVOp::IAdd => write!(f, "OpIAdd"),
23            SpirVOp::ISub => write!(f, "OpISub"),
24            SpirVOp::IMul => write!(f, "OpIMul"),
25            SpirVOp::SDiv => write!(f, "OpSDiv"),
26            SpirVOp::UDiv => write!(f, "OpUDiv"),
27            SpirVOp::SMod => write!(f, "OpSMod"),
28            SpirVOp::UMod => write!(f, "OpUMod"),
29            SpirVOp::SNegate => write!(f, "OpSNegate"),
30            SpirVOp::FAdd => write!(f, "OpFAdd"),
31            SpirVOp::FSub => write!(f, "OpFSub"),
32            SpirVOp::FMul => write!(f, "OpFMul"),
33            SpirVOp::FDiv => write!(f, "OpFDiv"),
34            SpirVOp::FMod => write!(f, "OpFMod"),
35            SpirVOp::FNegate => write!(f, "OpFNegate"),
36            SpirVOp::FRem => write!(f, "OpFRem"),
37            SpirVOp::IEqual => write!(f, "OpIEqual"),
38            SpirVOp::INotEqual => write!(f, "OpINotEqual"),
39            SpirVOp::SLessThan => write!(f, "OpSLessThan"),
40            SpirVOp::SLessThanEqual => write!(f, "OpSLessThanEqual"),
41            SpirVOp::SGreaterThan => write!(f, "OpSGreaterThan"),
42            SpirVOp::ULessThan => write!(f, "OpULessThan"),
43            SpirVOp::FOrdEqual => write!(f, "OpFOrdEqual"),
44            SpirVOp::FOrdLessThan => write!(f, "OpFOrdLessThan"),
45            SpirVOp::FOrdGreaterThan => write!(f, "OpFOrdGreaterThan"),
46            SpirVOp::LogicalAnd => write!(f, "OpLogicalAnd"),
47            SpirVOp::LogicalOr => write!(f, "OpLogicalOr"),
48            SpirVOp::LogicalNot => write!(f, "OpLogicalNot"),
49            SpirVOp::LogicalEqual => write!(f, "OpLogicalEqual"),
50            SpirVOp::BitwiseAnd => write!(f, "OpBitwiseAnd"),
51            SpirVOp::BitwiseOr => write!(f, "OpBitwiseOr"),
52            SpirVOp::BitwiseXor => write!(f, "OpBitwiseXor"),
53            SpirVOp::Not => write!(f, "OpNot"),
54            SpirVOp::ShiftLeftLogical => write!(f, "OpShiftLeftLogical"),
55            SpirVOp::ShiftRightLogical => write!(f, "OpShiftRightLogical"),
56            SpirVOp::ShiftRightArithmetic => write!(f, "OpShiftRightArithmetic"),
57            SpirVOp::ConvertFToS => write!(f, "OpConvertFToS"),
58            SpirVOp::ConvertFToU => write!(f, "OpConvertFToU"),
59            SpirVOp::ConvertSToF => write!(f, "OpConvertSToF"),
60            SpirVOp::ConvertUToF => write!(f, "OpConvertUToF"),
61            SpirVOp::FConvert => write!(f, "OpFConvert"),
62            SpirVOp::SConvert => write!(f, "OpSConvert"),
63            SpirVOp::UConvert => write!(f, "OpUConvert"),
64            SpirVOp::Bitcast => write!(f, "OpBitcast"),
65            SpirVOp::CompositeConstruct => write!(f, "OpCompositeConstruct"),
66            SpirVOp::CompositeExtract => write!(f, "OpCompositeExtract"),
67            SpirVOp::CompositeInsert => write!(f, "OpCompositeInsert"),
68            SpirVOp::VectorShuffle => write!(f, "OpVectorShuffle"),
69            SpirVOp::VectorExtractDynamic => write!(f, "OpVectorExtractDynamic"),
70            SpirVOp::VectorInsertDynamic => write!(f, "OpVectorInsertDynamic"),
71            SpirVOp::MatrixTimesVector => write!(f, "OpMatrixTimesVector"),
72            SpirVOp::VectorTimesMatrix => write!(f, "OpVectorTimesMatrix"),
73            SpirVOp::MatrixTimesMatrix => write!(f, "OpMatrixTimesMatrix"),
74            SpirVOp::MatrixTimesScalar => write!(f, "OpMatrixTimesScalar"),
75            SpirVOp::Dot => write!(f, "OpDot"),
76            SpirVOp::OuterProduct => write!(f, "OpOuterProduct"),
77            SpirVOp::Transpose => write!(f, "OpTranspose"),
78            SpirVOp::Label => write!(f, "OpLabel"),
79            SpirVOp::Branch => write!(f, "OpBranch"),
80            SpirVOp::BranchConditional => write!(f, "OpBranchConditional"),
81            SpirVOp::Switch => write!(f, "OpSwitch"),
82            SpirVOp::Return => write!(f, "OpReturn"),
83            SpirVOp::ReturnValue => write!(f, "OpReturnValue"),
84            SpirVOp::Unreachable => write!(f, "OpUnreachable"),
85            SpirVOp::Phi => write!(f, "OpPhi"),
86            SpirVOp::LoopMerge => write!(f, "OpLoopMerge"),
87            SpirVOp::SelectionMerge => write!(f, "OpSelectionMerge"),
88            SpirVOp::Function => write!(f, "OpFunction"),
89            SpirVOp::FunctionParameter => write!(f, "OpFunctionParameter"),
90            SpirVOp::FunctionEnd => write!(f, "OpFunctionEnd"),
91            SpirVOp::FunctionCall => write!(f, "OpFunctionCall"),
92            SpirVOp::ImageSampleImplicitLod => write!(f, "OpImageSampleImplicitLod"),
93            SpirVOp::ImageSampleExplicitLod => write!(f, "OpImageSampleExplicitLod"),
94            SpirVOp::ImageLoad => write!(f, "OpImageLoad"),
95            SpirVOp::ImageStore => write!(f, "OpImageStore"),
96            SpirVOp::AtomicLoad => write!(f, "OpAtomicLoad"),
97            SpirVOp::AtomicStore => write!(f, "OpAtomicStore"),
98            SpirVOp::AtomicIAdd => write!(f, "OpAtomicIAdd"),
99            SpirVOp::AtomicISub => write!(f, "OpAtomicISub"),
100            SpirVOp::AtomicCompareExchange => write!(f, "OpAtomicCompareExchange"),
101            SpirVOp::ExtInstGlsl(op) => write!(f, "OpExtInstGlsl({:?})", op),
102            SpirVOp::Capability(cap) => write!(f, "OpCapability({:?})", cap),
103            SpirVOp::Extension(ext) => write!(f, "OpExtension(\"{}\")", ext),
104            SpirVOp::ExtInstImport(set) => write!(f, "OpExtInstImport(\"{}\")", set),
105            SpirVOp::MemoryModel(addr, mem) => {
106                write!(f, "OpMemoryModel({:?}, {:?})", addr, mem)
107            }
108            SpirVOp::EntryPoint(model, name) => {
109                write!(f, "OpEntryPoint({:?}, \"{}\")", model, name)
110            }
111            SpirVOp::ExecutionMode(mode) => write!(f, "OpExecutionMode({:?})", mode),
112            SpirVOp::Decorate(deco) => write!(f, "OpDecorate({:?})", deco),
113            SpirVOp::MemberDecorate(idx, deco) => {
114                write!(f, "OpMemberDecorate({}, {:?})", idx, deco)
115            }
116            SpirVOp::Name(n) => write!(f, "OpName(\"{}\")", n),
117            SpirVOp::Constant(v) => write!(f, "OpConstant({})", v),
118            SpirVOp::ConstantComposite => write!(f, "OpConstantComposite"),
119            SpirVOp::ConstantTrue => write!(f, "OpConstantTrue"),
120            SpirVOp::ConstantFalse => write!(f, "OpConstantFalse"),
121            SpirVOp::TypeForwardPointer(sc) => write!(f, "OpTypeForwardPointer({})", sc),
122            SpirVOp::ControlBarrier => write!(f, "OpControlBarrier"),
123            SpirVOp::MemoryBarrier => write!(f, "OpMemoryBarrier"),
124        }
125    }
126}