llvm/tools/mlir/include/mlir/Dialect/AMDGPU/IR/AMDGPUEnums.h.inc

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

namespace mlir {
namespace amdgpu {
// The possible permutations for a DPP operation
enum class DPPPerm : uint32_t { … };

::std::optional<DPPPerm> symbolizeDPPPerm(uint32_t);
::llvm::StringRef stringifyDPPPerm(DPPPerm);
::std::optional<DPPPerm> symbolizeDPPPerm(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForDPPPerm() { … }


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

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

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

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

template<>
struct FieldParser<::mlir::amdgpu::DPPPerm, ::mlir::amdgpu::DPPPerm> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::amdgpu::DPPPerm> { … };
}

namespace mlir {
namespace amdgpu {
// The possible permutations of the lanes storing B available in an MFMA
enum class MFMAPermB : uint32_t { … };

::std::optional<MFMAPermB> symbolizeMFMAPermB(uint32_t);
::llvm::StringRef stringifyMFMAPermB(MFMAPermB);
::std::optional<MFMAPermB> symbolizeMFMAPermB(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForMFMAPermB() { … }


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

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

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

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

template<>
struct FieldParser<::mlir::amdgpu::MFMAPermB, ::mlir::amdgpu::MFMAPermB> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::amdgpu::MFMAPermB> { … };
}

namespace mlir {
namespace amdgpu {
// The possible options for scheduling barriers
enum class sched_barrier_opt_enum : uint32_t { … };

::std::optional<sched_barrier_opt_enum> symbolizesched_barrier_opt_enum(uint32_t);
std::string stringifysched_barrier_opt_enum(sched_barrier_opt_enum);
::std::optional<sched_barrier_opt_enum> symbolizesched_barrier_opt_enum(::llvm::StringRef);

inline constexpr sched_barrier_opt_enum operator|(sched_barrier_opt_enum a, sched_barrier_opt_enum b) { … }
inline constexpr sched_barrier_opt_enum operator&(sched_barrier_opt_enum a, sched_barrier_opt_enum b) { … }
inline constexpr sched_barrier_opt_enum operator^(sched_barrier_opt_enum a, sched_barrier_opt_enum b) { … }
inline constexpr sched_barrier_opt_enum operator~(sched_barrier_opt_enum bits) { … }
inline constexpr bool bitEnumContainsAll(sched_barrier_opt_enum bits, sched_barrier_opt_enum bit) { … }
inline constexpr bool bitEnumContainsAny(sched_barrier_opt_enum bits, sched_barrier_opt_enum bit) { … }
inline constexpr sched_barrier_opt_enum bitEnumClear(sched_barrier_opt_enum bits, sched_barrier_opt_enum bit) { … }
inline constexpr sched_barrier_opt_enum bitEnumSet(sched_barrier_opt_enum bits, sched_barrier_opt_enum bit, /*optional*/bool value=true) { … }
  
inline std::string stringifyEnum(sched_barrier_opt_enum enumValue) { … }

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

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

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

template<>
struct FieldParser<::mlir::amdgpu::sched_barrier_opt_enum, ::mlir::amdgpu::sched_barrier_opt_enum> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::amdgpu::sched_barrier_opt_enum> { … };
}