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

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

namespace mlir {
namespace gpu {
// GPU address space
enum class AddressSpace : uint32_t { … };

::std::optional<AddressSpace> symbolizeAddressSpace(uint32_t);
::llvm::StringRef stringifyAddressSpace(AddressSpace);
::std::optional<AddressSpace> symbolizeAddressSpace(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForAddressSpace() { … }


inline ::llvm::StringRef stringifyEnum(AddressSpace enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<AddressSpace> symbolizeEnum<AddressSpace>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::AddressSpace, ::mlir::gpu::AddressSpace> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::AddressSpace value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::AddressSpace> { … };
}

namespace mlir {
namespace gpu {
// built-in reduction operations supported by gpu.allreduce.
enum class AllReduceOperation : uint32_t { … };

::std::optional<AllReduceOperation> symbolizeAllReduceOperation(uint32_t);
::llvm::StringRef stringifyAllReduceOperation(AllReduceOperation);
::std::optional<AllReduceOperation> symbolizeAllReduceOperation(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForAllReduceOperation() { … }


inline ::llvm::StringRef stringifyEnum(AllReduceOperation enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<AllReduceOperation> symbolizeEnum<AllReduceOperation>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::AllReduceOperation, ::mlir::gpu::AllReduceOperation> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::AllReduceOperation value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::AllReduceOperation> { … };
}

namespace mlir {
namespace gpu {
// GPU compilation format
enum class CompilationTarget : uint32_t { … };

::std::optional<CompilationTarget> symbolizeCompilationTarget(uint32_t);
::llvm::StringRef stringifyCompilationTarget(CompilationTarget);
::std::optional<CompilationTarget> symbolizeCompilationTarget(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForCompilationTarget() { … }


inline ::llvm::StringRef stringifyEnum(CompilationTarget enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<CompilationTarget> symbolizeEnum<CompilationTarget>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::CompilationTarget, ::mlir::gpu::CompilationTarget> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::CompilationTarget value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::CompilationTarget> { … };
}

namespace mlir {
namespace gpu {
// a dimension, either 'x', 'y', or 'z'
enum class Dimension : uint32_t { … };

::std::optional<Dimension> symbolizeDimension(uint32_t);
::llvm::StringRef stringifyDimension(Dimension);
::std::optional<Dimension> symbolizeDimension(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForDimension() { … }


inline ::llvm::StringRef stringifyEnum(Dimension enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<Dimension> symbolizeEnum<Dimension>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::Dimension, ::mlir::gpu::Dimension> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::Dimension value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::Dimension> { … };
}

namespace mlir {
namespace gpu {
// pruning strategy for 2:4 sparse matrix
enum class Prune2To4SpMatFlag : uint32_t { … };

::std::optional<Prune2To4SpMatFlag> symbolizePrune2To4SpMatFlag(uint32_t);
::llvm::StringRef stringifyPrune2To4SpMatFlag(Prune2To4SpMatFlag);
::std::optional<Prune2To4SpMatFlag> symbolizePrune2To4SpMatFlag(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForPrune2To4SpMatFlag() { … }


inline ::llvm::StringRef stringifyEnum(Prune2To4SpMatFlag enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<Prune2To4SpMatFlag> symbolizeEnum<Prune2To4SpMatFlag>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::Prune2To4SpMatFlag, ::mlir::gpu::Prune2To4SpMatFlag> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::Prune2To4SpMatFlag value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::Prune2To4SpMatFlag> { … };
}

namespace mlir {
namespace gpu {
// Indexing modes supported by gpu.shuffle.
enum class ShuffleMode : uint32_t { … };

::std::optional<ShuffleMode> symbolizeShuffleMode(uint32_t);
::llvm::StringRef stringifyShuffleMode(ShuffleMode);
::std::optional<ShuffleMode> symbolizeShuffleMode(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForShuffleMode() { … }


inline ::llvm::StringRef stringifyEnum(ShuffleMode enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<ShuffleMode> symbolizeEnum<ShuffleMode>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::ShuffleMode, ::mlir::gpu::ShuffleMode> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::ShuffleMode value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::ShuffleMode> { … };
}

namespace mlir {
namespace gpu {
// choose whether spgemm_work_estimation_or_compute does work estimation or compute
enum class SpGEMMWorkEstimationOrComputeKind : uint32_t { … };

::std::optional<SpGEMMWorkEstimationOrComputeKind> symbolizeSpGEMMWorkEstimationOrComputeKind(uint32_t);
::llvm::StringRef stringifySpGEMMWorkEstimationOrComputeKind(SpGEMMWorkEstimationOrComputeKind);
::std::optional<SpGEMMWorkEstimationOrComputeKind> symbolizeSpGEMMWorkEstimationOrComputeKind(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForSpGEMMWorkEstimationOrComputeKind() { … }


inline ::llvm::StringRef stringifyEnum(SpGEMMWorkEstimationOrComputeKind enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<SpGEMMWorkEstimationOrComputeKind> symbolizeEnum<SpGEMMWorkEstimationOrComputeKind>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::SpGEMMWorkEstimationOrComputeKind, ::mlir::gpu::SpGEMMWorkEstimationOrComputeKind> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::SpGEMMWorkEstimationOrComputeKind value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::SpGEMMWorkEstimationOrComputeKind> { … };
}

namespace mlir {
namespace gpu {
// transpose mode of sparse matrix supported by sparse tensor ops
enum class TransposeMode : uint32_t { … };

::std::optional<TransposeMode> symbolizeTransposeMode(uint32_t);
::llvm::StringRef stringifyTransposeMode(TransposeMode);
::std::optional<TransposeMode> symbolizeTransposeMode(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForTransposeMode() { … }


inline ::llvm::StringRef stringifyEnum(TransposeMode enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<TransposeMode> symbolizeEnum<TransposeMode>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::TransposeMode, ::mlir::gpu::TransposeMode> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::TransposeMode value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::TransposeMode> { … };
}

namespace mlir {
namespace gpu {
// elementwise operation to apply to mma matrix
enum class MMAElementwiseOp : uint32_t { … };

::std::optional<MMAElementwiseOp> symbolizeMMAElementwiseOp(uint32_t);
::llvm::StringRef stringifyMMAElementwiseOp(MMAElementwiseOp);
::std::optional<MMAElementwiseOp> symbolizeMMAElementwiseOp(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForMMAElementwiseOp() { … }


inline ::llvm::StringRef stringifyEnum(MMAElementwiseOp enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<MMAElementwiseOp> symbolizeEnum<MMAElementwiseOp>(::llvm::StringRef str) { … }
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::MMAElementwiseOp, ::mlir::gpu::MMAElementwiseOp> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::MMAElementwiseOp value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::MMAElementwiseOp> { … };
}

namespace mlir {
namespace gpu {
// Mapping ids for loop mapping
enum class MappingId : uint64_t { … };

::std::optional<MappingId> symbolizeMappingId(uint64_t);
::llvm::StringRef stringifyMappingId(MappingId);
::std::optional<MappingId> symbolizeMappingId(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForMappingId() { … }


inline ::llvm::StringRef stringifyEnum(MappingId enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<MappingId> symbolizeEnum<MappingId>(::llvm::StringRef str) { … }

class MappingIdAttr : public ::mlir::IntegerAttr { … };
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::MappingId, ::mlir::gpu::MappingId> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::MappingId value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::MappingId> { … };
}

namespace mlir {
namespace gpu {
// processor for loop mapping
enum class Processor : uint64_t { … };

::std::optional<Processor> symbolizeProcessor(uint64_t);
::llvm::StringRef stringifyProcessor(Processor);
::std::optional<Processor> symbolizeProcessor(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForProcessor() { … }


inline ::llvm::StringRef stringifyEnum(Processor enumValue) { … }

template <typename EnumType>
::std::optional<EnumType> symbolizeEnum(::llvm::StringRef);

template <>
inline ::std::optional<Processor> symbolizeEnum<Processor>(::llvm::StringRef str) { … }

class ProcessorAttr : public ::mlir::IntegerAttr { … };
} // namespace gpu
} // namespace mlir

namespace mlir {
template <typename T, typename>
struct FieldParser;

template<>
struct FieldParser<::mlir::gpu::Processor, ::mlir::gpu::Processor> { … };
} // namespace mlir

namespace llvm {
inline ::llvm::raw_ostream &operator<<(::llvm::raw_ostream &p, ::mlir::gpu::Processor value) { … }
} // namespace llvm

namespace llvm {
template<> struct DenseMapInfo<::mlir::gpu::Processor> { … };
}