SPIRVEnums.cpp.inc | Explore in Territory

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Enum Utility Definitions                                                   *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|* From: SPIRVBase.td                                                         *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyVersion(Version val) { … }

::std::optional<Version> symbolizeVersion(::llvm::StringRef str) { … }
::std::optional<Version> symbolizeVersion(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyDeviceType(DeviceType val) { … }

::std::optional<DeviceType> symbolizeDeviceType(::llvm::StringRef str) { … }
::std::optional<DeviceType> symbolizeDeviceType(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyVendor(Vendor val) { … }

::std::optional<Vendor> symbolizeVendor(::llvm::StringRef str) { … }
::std::optional<Vendor> symbolizeVendor(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyClientAPI(ClientAPI val) { … }

::std::optional<ClientAPI> symbolizeClientAPI(::llvm::StringRef str) { … }
::std::optional<ClientAPI> symbolizeClientAPI(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyExtension(Extension val) { … }

::std::optional<Extension> symbolizeExtension(::llvm::StringRef str) { … }
::std::optional<Extension> symbolizeExtension(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyCapability(Capability val) { … }

::std::optional<Capability> symbolizeCapability(::llvm::StringRef str) { … }
::std::optional<Capability> symbolizeCapability(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyAddressingModel(AddressingModel val) { … }

::std::optional<AddressingModel> symbolizeAddressingModel(::llvm::StringRef str) { … }
::std::optional<AddressingModel> symbolizeAddressingModel(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyBuiltIn(BuiltIn val) { … }

::std::optional<BuiltIn> symbolizeBuiltIn(::llvm::StringRef str) { … }
::std::optional<BuiltIn> symbolizeBuiltIn(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyDecoration(Decoration val) { … }

::std::optional<Decoration> symbolizeDecoration(::llvm::StringRef str) { … }
::std::optional<Decoration> symbolizeDecoration(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyDim(Dim val) { … }

::std::optional<Dim> symbolizeDim(::llvm::StringRef str) { … }
::std::optional<Dim> symbolizeDim(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyExecutionMode(ExecutionMode val) { … }

::std::optional<ExecutionMode> symbolizeExecutionMode(::llvm::StringRef str) { … }
::std::optional<ExecutionMode> symbolizeExecutionMode(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyExecutionModel(ExecutionModel val) { … }

::std::optional<ExecutionModel> symbolizeExecutionModel(::llvm::StringRef str) { … }
::std::optional<ExecutionModel> symbolizeExecutionModel(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyFPRoundingMode(FPRoundingMode val) { … }

::std::optional<FPRoundingMode> symbolizeFPRoundingMode(::llvm::StringRef str) { … }
::std::optional<FPRoundingMode> symbolizeFPRoundingMode(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyFunctionControl(FunctionControl symbol) { … }

::std::optional<FunctionControl> symbolizeFunctionControl(::llvm::StringRef str) { … }

::std::optional<FunctionControl> symbolizeFunctionControl(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyGroupOperation(GroupOperation val) { … }

::std::optional<GroupOperation> symbolizeGroupOperation(::llvm::StringRef str) { … }
::std::optional<GroupOperation> symbolizeGroupOperation(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyImageFormat(ImageFormat val) { … }

::std::optional<ImageFormat> symbolizeImageFormat(::llvm::StringRef str) { … }
::std::optional<ImageFormat> symbolizeImageFormat(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyImageOperands(ImageOperands symbol) { … }

::std::optional<ImageOperands> symbolizeImageOperands(::llvm::StringRef str) { … }

::std::optional<ImageOperands> symbolizeImageOperands(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyLinkageType(LinkageType val) { … }

::std::optional<LinkageType> symbolizeLinkageType(::llvm::StringRef str) { … }
::std::optional<LinkageType> symbolizeLinkageType(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyLoopControl(LoopControl symbol) { … }

::std::optional<LoopControl> symbolizeLoopControl(::llvm::StringRef str) { … }

::std::optional<LoopControl> symbolizeLoopControl(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyMemoryAccess(MemoryAccess symbol) { … }

::std::optional<MemoryAccess> symbolizeMemoryAccess(::llvm::StringRef str) { … }

::std::optional<MemoryAccess> symbolizeMemoryAccess(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyMemoryModel(MemoryModel val) { … }

::std::optional<MemoryModel> symbolizeMemoryModel(::llvm::StringRef str) { … }
::std::optional<MemoryModel> symbolizeMemoryModel(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyMemorySemantics(MemorySemantics symbol) { … }

::std::optional<MemorySemantics> symbolizeMemorySemantics(::llvm::StringRef str) { … }

::std::optional<MemorySemantics> symbolizeMemorySemantics(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyScope(Scope val) { … }

::std::optional<Scope> symbolizeScope(::llvm::StringRef str) { … }
::std::optional<Scope> symbolizeScope(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifySelectionControl(SelectionControl symbol) { … }

::std::optional<SelectionControl> symbolizeSelectionControl(::llvm::StringRef str) { … }

::std::optional<SelectionControl> symbolizeSelectionControl(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyStorageClass(StorageClass val) { … }

::std::optional<StorageClass> symbolizeStorageClass(::llvm::StringRef str) { … }
::std::optional<StorageClass> symbolizeStorageClass(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyPackedVectorFormat(PackedVectorFormat val) { … }

::std::optional<PackedVectorFormat> symbolizePackedVectorFormat(::llvm::StringRef str) { … }
::std::optional<PackedVectorFormat> symbolizePackedVectorFormat(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyImageDepthInfo(ImageDepthInfo val) { … }

::std::optional<ImageDepthInfo> symbolizeImageDepthInfo(::llvm::StringRef str) { … }
::std::optional<ImageDepthInfo> symbolizeImageDepthInfo(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyImageArrayedInfo(ImageArrayedInfo val) { … }

::std::optional<ImageArrayedInfo> symbolizeImageArrayedInfo(::llvm::StringRef str) { … }
::std::optional<ImageArrayedInfo> symbolizeImageArrayedInfo(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyImageSamplingInfo(ImageSamplingInfo val) { … }

::std::optional<ImageSamplingInfo> symbolizeImageSamplingInfo(::llvm::StringRef str) { … }
::std::optional<ImageSamplingInfo> symbolizeImageSamplingInfo(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyImageSamplerUseInfo(ImageSamplerUseInfo val) { … }

::std::optional<ImageSamplerUseInfo> symbolizeImageSamplerUseInfo(::llvm::StringRef str) { … }
::std::optional<ImageSamplerUseInfo> symbolizeImageSamplerUseInfo(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyMatrixLayout(MatrixLayout val) { … }

::std::optional<MatrixLayout> symbolizeMatrixLayout(::llvm::StringRef str) { … }
::std::optional<MatrixLayout> symbolizeMatrixLayout(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyCooperativeMatrixUseKHR(CooperativeMatrixUseKHR val) { … }

::std::optional<CooperativeMatrixUseKHR> symbolizeCooperativeMatrixUseKHR(::llvm::StringRef str) { … }
::std::optional<CooperativeMatrixUseKHR> symbolizeCooperativeMatrixUseKHR(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyCooperativeMatrixLayoutKHR(CooperativeMatrixLayoutKHR val) { … }

::std::optional<CooperativeMatrixLayoutKHR> symbolizeCooperativeMatrixLayoutKHR(::llvm::StringRef str) { … }
::std::optional<CooperativeMatrixLayoutKHR> symbolizeCooperativeMatrixLayoutKHR(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyCooperativeMatrixOperandsKHR(CooperativeMatrixOperandsKHR symbol) { … }

::std::optional<CooperativeMatrixOperandsKHR> symbolizeCooperativeMatrixOperandsKHR(::llvm::StringRef str) { … }

::std::optional<CooperativeMatrixOperandsKHR> symbolizeCooperativeMatrixOperandsKHR(uint32_t value) { … }
} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
::llvm::StringRef stringifyOpcode(Opcode val) { … }

::std::optional<Opcode> symbolizeOpcode(::llvm::StringRef str) { … }
::std::optional<Opcode> symbolizeOpcode(uint32_t value) { … }

} // namespace spirv
} // namespace mlir

namespace mlir {
namespace spirv {
std::string stringifyFPFastMathMode(FPFastMathMode symbol) { … }

::std::optional<FPFastMathMode> symbolizeFPFastMathMode(::llvm::StringRef str) { … }

::std::optional<FPFastMathMode> symbolizeFPFastMathMode(uint32_t value) { … }
} // namespace spirv
} // namespace mlir
llvm/tools/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVEnums.cpp.inc
