ArithOpsEnums.h.inc | Explore in Territory

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

namespace mlir {
namespace arith {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
enum class CmpFPredicate : uint64_t { … };

::std::optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t);
::llvm::StringRef stringifyCmpFPredicate(CmpFPredicate);
::std::optional<CmpFPredicate> symbolizeCmpFPredicate(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForCmpFPredicate() { … }


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

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

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

class CmpFPredicateAttr : public ::mlir::IntegerAttr { … };
} // namespace arith
} // namespace mlir

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

template<>
struct FieldParser<::mlir::arith::CmpFPredicate, ::mlir::arith::CmpFPredicate> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::CmpFPredicate> { … };
}

namespace mlir {
namespace arith {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
enum class CmpIPredicate : uint64_t { … };

::std::optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t);
::llvm::StringRef stringifyCmpIPredicate(CmpIPredicate);
::std::optional<CmpIPredicate> symbolizeCmpIPredicate(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForCmpIPredicate() { … }


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

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

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

class CmpIPredicateAttr : public ::mlir::IntegerAttr { … };
} // namespace arith
} // namespace mlir

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

template<>
struct FieldParser<::mlir::arith::CmpIPredicate, ::mlir::arith::CmpIPredicate> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::CmpIPredicate> { … };
}

namespace mlir {
namespace arith {
// Integer overflow arith flags
enum class IntegerOverflowFlags : uint32_t { … };

::std::optional<IntegerOverflowFlags> symbolizeIntegerOverflowFlags(uint32_t);
std::string stringifyIntegerOverflowFlags(IntegerOverflowFlags);
::std::optional<IntegerOverflowFlags> symbolizeIntegerOverflowFlags(::llvm::StringRef);

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

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

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

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

template<>
struct FieldParser<::mlir::arith::IntegerOverflowFlags, ::mlir::arith::IntegerOverflowFlags> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::IntegerOverflowFlags> { … };
}

namespace mlir {
namespace arith {
// Floating point rounding mode
enum class RoundingMode : uint32_t { … };

::std::optional<RoundingMode> symbolizeRoundingMode(uint32_t);
::llvm::StringRef stringifyRoundingMode(RoundingMode);
::std::optional<RoundingMode> symbolizeRoundingMode(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForRoundingMode() { … }


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

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

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

class RoundingModeAttr : public ::mlir::IntegerAttr { … };
} // namespace arith
} // namespace mlir

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

template<>
struct FieldParser<::mlir::arith::RoundingMode, ::mlir::arith::RoundingMode> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::RoundingMode> { … };
}

namespace mlir {
namespace arith {
// allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
enum class AtomicRMWKind : uint64_t { … };

::std::optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t);
::llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind);
::std::optional<AtomicRMWKind> symbolizeAtomicRMWKind(::llvm::StringRef);
inline constexpr unsigned getMaxEnumValForAtomicRMWKind() { … }


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

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

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

class AtomicRMWKindAttr : public ::mlir::IntegerAttr { … };
} // namespace arith
} // namespace mlir

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

template<>
struct FieldParser<::mlir::arith::AtomicRMWKind, ::mlir::arith::AtomicRMWKind> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::AtomicRMWKind> { … };
}

namespace mlir {
namespace arith {
// Floating point fast math flags
enum class FastMathFlags : uint32_t { … };

::std::optional<FastMathFlags> symbolizeFastMathFlags(uint32_t);
std::string stringifyFastMathFlags(FastMathFlags);
::std::optional<FastMathFlags> symbolizeFastMathFlags(::llvm::StringRef);

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

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

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

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

template<>
struct FieldParser<::mlir::arith::FastMathFlags, ::mlir::arith::FastMathFlags> { … };
} // namespace mlir

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

namespace llvm {
template<> struct DenseMapInfo<::mlir::arith::FastMathFlags> { … };
}
llvm/tools/mlir/include/mlir/Dialect/Arith/IR/ArithOpsEnums.h.inc
