llvm/tools/mlir/include/mlir/Dialect/Arith/IR/ArithOpsEnums.cpp.inc

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

namespace mlir {
namespace arith {
::llvm::StringRef stringifyCmpFPredicate(CmpFPredicate val) { … }

::std::optional<CmpFPredicate> symbolizeCmpFPredicate(::llvm::StringRef str) { … }
::std::optional<CmpFPredicate> symbolizeCmpFPredicate(uint64_t value) { … }

bool CmpFPredicateAttr::classof(::mlir::Attribute attr) { … }
CmpFPredicateAttr CmpFPredicateAttr::get(::mlir::MLIRContext *context, CmpFPredicate val) { … }
CmpFPredicate CmpFPredicateAttr::getValue() const { … }
} // namespace arith
} // namespace mlir

namespace mlir {
namespace arith {
::llvm::StringRef stringifyCmpIPredicate(CmpIPredicate val) { … }

::std::optional<CmpIPredicate> symbolizeCmpIPredicate(::llvm::StringRef str) { … }
::std::optional<CmpIPredicate> symbolizeCmpIPredicate(uint64_t value) { … }

bool CmpIPredicateAttr::classof(::mlir::Attribute attr) { … }
CmpIPredicateAttr CmpIPredicateAttr::get(::mlir::MLIRContext *context, CmpIPredicate val) { … }
CmpIPredicate CmpIPredicateAttr::getValue() const { … }
} // namespace arith
} // namespace mlir

namespace mlir {
namespace arith {
std::string stringifyIntegerOverflowFlags(IntegerOverflowFlags symbol) { … }

::std::optional<IntegerOverflowFlags> symbolizeIntegerOverflowFlags(::llvm::StringRef str) { … }

::std::optional<IntegerOverflowFlags> symbolizeIntegerOverflowFlags(uint32_t value) { … }
} // namespace arith
} // namespace mlir

namespace mlir {
namespace arith {
::llvm::StringRef stringifyRoundingMode(RoundingMode val) { … }

::std::optional<RoundingMode> symbolizeRoundingMode(::llvm::StringRef str) { … }
::std::optional<RoundingMode> symbolizeRoundingMode(uint32_t value) { … }

bool RoundingModeAttr::classof(::mlir::Attribute attr) { … }
RoundingModeAttr RoundingModeAttr::get(::mlir::MLIRContext *context, RoundingMode val) { … }
RoundingMode RoundingModeAttr::getValue() const { … }
} // namespace arith
} // namespace mlir

namespace mlir {
namespace arith {
::llvm::StringRef stringifyAtomicRMWKind(AtomicRMWKind val) { … }

::std::optional<AtomicRMWKind> symbolizeAtomicRMWKind(::llvm::StringRef str) { … }
::std::optional<AtomicRMWKind> symbolizeAtomicRMWKind(uint64_t value) { … }

bool AtomicRMWKindAttr::classof(::mlir::Attribute attr) { … }
AtomicRMWKindAttr AtomicRMWKindAttr::get(::mlir::MLIRContext *context, AtomicRMWKind val) { … }
AtomicRMWKind AtomicRMWKindAttr::getValue() const { … }
} // namespace arith
} // namespace mlir

namespace mlir {
namespace arith {
std::string stringifyFastMathFlags(FastMathFlags symbol) { … }

::std::optional<FastMathFlags> symbolizeFastMathFlags(::llvm::StringRef str) { … }

::std::optional<FastMathFlags> symbolizeFastMathFlags(uint32_t value) { … }
} // namespace arith
} // namespace mlir