llvm/tools/mlir/include/mlir/Dialect/GPU/IR/GPUOpsEnums.cpp.inc

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

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyAddressSpace(AddressSpace val) { … }

::std::optional<AddressSpace> symbolizeAddressSpace(::llvm::StringRef str) { … }
::std::optional<AddressSpace> symbolizeAddressSpace(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyAllReduceOperation(AllReduceOperation val) { … }

::std::optional<AllReduceOperation> symbolizeAllReduceOperation(::llvm::StringRef str) { … }
::std::optional<AllReduceOperation> symbolizeAllReduceOperation(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyCompilationTarget(CompilationTarget val) { … }

::std::optional<CompilationTarget> symbolizeCompilationTarget(::llvm::StringRef str) { … }
::std::optional<CompilationTarget> symbolizeCompilationTarget(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyDimension(Dimension val) { … }

::std::optional<Dimension> symbolizeDimension(::llvm::StringRef str) { … }
::std::optional<Dimension> symbolizeDimension(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyPrune2To4SpMatFlag(Prune2To4SpMatFlag val) { … }

::std::optional<Prune2To4SpMatFlag> symbolizePrune2To4SpMatFlag(::llvm::StringRef str) { … }
::std::optional<Prune2To4SpMatFlag> symbolizePrune2To4SpMatFlag(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyShuffleMode(ShuffleMode val) { … }

::std::optional<ShuffleMode> symbolizeShuffleMode(::llvm::StringRef str) { … }
::std::optional<ShuffleMode> symbolizeShuffleMode(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifySpGEMMWorkEstimationOrComputeKind(SpGEMMWorkEstimationOrComputeKind val) { … }

::std::optional<SpGEMMWorkEstimationOrComputeKind> symbolizeSpGEMMWorkEstimationOrComputeKind(::llvm::StringRef str) { … }
::std::optional<SpGEMMWorkEstimationOrComputeKind> symbolizeSpGEMMWorkEstimationOrComputeKind(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyTransposeMode(TransposeMode val) { … }

::std::optional<TransposeMode> symbolizeTransposeMode(::llvm::StringRef str) { … }
::std::optional<TransposeMode> symbolizeTransposeMode(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyMMAElementwiseOp(MMAElementwiseOp val) { … }

::std::optional<MMAElementwiseOp> symbolizeMMAElementwiseOp(::llvm::StringRef str) { … }
::std::optional<MMAElementwiseOp> symbolizeMMAElementwiseOp(uint32_t value) { … }

} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyMappingId(MappingId val) { … }

::std::optional<MappingId> symbolizeMappingId(::llvm::StringRef str) { … }
::std::optional<MappingId> symbolizeMappingId(uint64_t value) { … }

bool MappingIdAttr::classof(::mlir::Attribute attr) { … }
MappingIdAttr MappingIdAttr::get(::mlir::MLIRContext *context, MappingId val) { … }
MappingId MappingIdAttr::getValue() const { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
namespace gpu {
::llvm::StringRef stringifyProcessor(Processor val) { … }

::std::optional<Processor> symbolizeProcessor(::llvm::StringRef str) { … }
::std::optional<Processor> symbolizeProcessor(uint64_t value) { … }

bool ProcessorAttr::classof(::mlir::Attribute attr) { … }
ProcessorAttr ProcessorAttr::get(::mlir::MLIRContext *context, Processor val) { … }
Processor ProcessorAttr::getValue() const { … }
} // namespace gpu
} // namespace mlir