LLVMOpsEnums.cpp.inc | Explore in Territory

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

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyAsmDialect(AsmDialect val) { … }

::std::optional<AsmDialect> symbolizeAsmDialect(::llvm::StringRef str) { … }
::std::optional<AsmDialect> symbolizeAsmDialect(uint64_t value) { … }

bool AsmDialectAttr::classof(::mlir::Attribute attr) { … }
AsmDialectAttr AsmDialectAttr::get(::mlir::MLIRContext *context, AsmDialect val) { … }
AsmDialect AsmDialectAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyAtomicBinOp(AtomicBinOp val) { … }

::std::optional<AtomicBinOp> symbolizeAtomicBinOp(::llvm::StringRef str) { … }
::std::optional<AtomicBinOp> symbolizeAtomicBinOp(uint64_t value) { … }

bool AtomicBinOpAttr::classof(::mlir::Attribute attr) { … }
AtomicBinOpAttr AtomicBinOpAttr::get(::mlir::MLIRContext *context, AtomicBinOp val) { … }
AtomicBinOp AtomicBinOpAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyAtomicOrdering(AtomicOrdering val) { … }

::std::optional<AtomicOrdering> symbolizeAtomicOrdering(::llvm::StringRef str) { … }
::std::optional<AtomicOrdering> symbolizeAtomicOrdering(uint64_t value) { … }

bool AtomicOrderingAttr::classof(::mlir::Attribute attr) { … }
AtomicOrderingAttr AtomicOrderingAttr::get(::mlir::MLIRContext *context, AtomicOrdering val) { … }
AtomicOrdering AtomicOrderingAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
namespace cconv {
::llvm::StringRef stringifyCConv(CConv val) { … }

::std::optional<CConv> symbolizeCConv(::llvm::StringRef str) { … }
::std::optional<CConv> symbolizeCConv(uint64_t value) { … }

bool CConvAttr::classof(::mlir::Attribute attr) { … }
CConvAttr CConvAttr::get(::mlir::MLIRContext *context, CConv val) { … }
CConv CConvAttr::getValue() const { … }
} // namespace cconv
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
namespace comdat {
::llvm::StringRef stringifyComdat(Comdat val) { … }

::std::optional<Comdat> symbolizeComdat(::llvm::StringRef str) { … }
::std::optional<Comdat> symbolizeComdat(uint64_t value) { … }

bool ComdatAttr::classof(::mlir::Attribute attr) { … }
ComdatAttr ComdatAttr::get(::mlir::MLIRContext *context, Comdat val) { … }
Comdat ComdatAttr::getValue() const { … }
} // namespace comdat
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
std::string stringifyDIFlags(DIFlags symbol) { … }

::std::optional<DIFlags> symbolizeDIFlags(::llvm::StringRef str) { … }

::std::optional<DIFlags> symbolizeDIFlags(uint32_t value) { … }
bool DIFlagsAttr::classof(::mlir::Attribute attr) { … }
DIFlagsAttr DIFlagsAttr::get(::mlir::MLIRContext *context, DIFlags val) { … }
DIFlags DIFlagsAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
std::string stringifyDISubprogramFlags(DISubprogramFlags symbol) { … }

::std::optional<DISubprogramFlags> symbolizeDISubprogramFlags(::llvm::StringRef str) { … }

::std::optional<DISubprogramFlags> symbolizeDISubprogramFlags(uint32_t value) { … }
bool DISubprogramFlagsAttr::classof(::mlir::Attribute attr) { … }
DISubprogramFlagsAttr DISubprogramFlagsAttr::get(::mlir::MLIRContext *context, DISubprogramFlags val) { … }
DISubprogramFlags DISubprogramFlagsAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyFCmpPredicate(FCmpPredicate val) { … }

::std::optional<FCmpPredicate> symbolizeFCmpPredicate(::llvm::StringRef str) { … }
::std::optional<FCmpPredicate> symbolizeFCmpPredicate(uint64_t value) { … }

bool FCmpPredicateAttr::classof(::mlir::Attribute attr) { … }
FCmpPredicateAttr FCmpPredicateAttr::get(::mlir::MLIRContext *context, FCmpPredicate val) { … }
FCmpPredicate FCmpPredicateAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyFPExceptionBehavior(FPExceptionBehavior val) { … }

::std::optional<FPExceptionBehavior> symbolizeFPExceptionBehavior(::llvm::StringRef str) { … }
::std::optional<FPExceptionBehavior> symbolizeFPExceptionBehavior(uint64_t value) { … }

bool FPExceptionBehaviorAttr::classof(::mlir::Attribute attr) { … }
FPExceptionBehaviorAttr FPExceptionBehaviorAttr::get(::mlir::MLIRContext *context, FPExceptionBehavior val) { … }
FPExceptionBehavior FPExceptionBehaviorAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
std::string stringifyFastmathFlags(FastmathFlags symbol) { … }

::std::optional<FastmathFlags> symbolizeFastmathFlags(::llvm::StringRef str) { … }

::std::optional<FastmathFlags> symbolizeFastmathFlags(uint32_t value) { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
namespace framePointerKind {
::llvm::StringRef stringifyFramePointerKind(FramePointerKind val) { … }

::std::optional<FramePointerKind> symbolizeFramePointerKind(::llvm::StringRef str) { … }
::std::optional<FramePointerKind> symbolizeFramePointerKind(uint64_t value) { … }

bool FramePointerKindAttr::classof(::mlir::Attribute attr) { … }
FramePointerKindAttr FramePointerKindAttr::get(::mlir::MLIRContext *context, FramePointerKind val) { … }
FramePointerKind FramePointerKindAttr::getValue() const { … }
} // namespace framePointerKind
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyICmpPredicate(ICmpPredicate val) { … }

::std::optional<ICmpPredicate> symbolizeICmpPredicate(::llvm::StringRef str) { … }
::std::optional<ICmpPredicate> symbolizeICmpPredicate(uint64_t value) { … }

bool ICmpPredicateAttr::classof(::mlir::Attribute attr) { … }
ICmpPredicateAttr ICmpPredicateAttr::get(::mlir::MLIRContext *context, ICmpPredicate val) { … }
ICmpPredicate ICmpPredicateAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

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

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

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

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyDIEmissionKind(DIEmissionKind val) { … }

::std::optional<DIEmissionKind> symbolizeDIEmissionKind(::llvm::StringRef str) { … }
::std::optional<DIEmissionKind> symbolizeDIEmissionKind(uint64_t value) { … }

bool DIEmissionKindAttr::classof(::mlir::Attribute attr) { … }
DIEmissionKindAttr DIEmissionKindAttr::get(::mlir::MLIRContext *context, DIEmissionKind val) { … }
DIEmissionKind DIEmissionKindAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyDINameTableKind(DINameTableKind val) { … }

::std::optional<DINameTableKind> symbolizeDINameTableKind(::llvm::StringRef str) { … }
::std::optional<DINameTableKind> symbolizeDINameTableKind(uint64_t value) { … }

bool DINameTableKindAttr::classof(::mlir::Attribute attr) { … }
DINameTableKindAttr DINameTableKindAttr::get(::mlir::MLIRContext *context, DINameTableKind val) { … }
DINameTableKind DINameTableKindAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
namespace linkage {
::llvm::StringRef stringifyLinkage(Linkage val) { … }

::std::optional<Linkage> symbolizeLinkage(::llvm::StringRef str) { … }
::std::optional<Linkage> symbolizeLinkage(uint64_t value) { … }

bool LinkageAttr::classof(::mlir::Attribute attr) { … }
LinkageAttr LinkageAttr::get(::mlir::MLIRContext *context, Linkage val) { … }
Linkage LinkageAttr::getValue() const { … }
} // namespace linkage
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyModRefInfo(ModRefInfo val) { … }

::std::optional<ModRefInfo> symbolizeModRefInfo(::llvm::StringRef str) { … }
::std::optional<ModRefInfo> symbolizeModRefInfo(uint64_t value) { … }

bool ModRefInfoAttr::classof(::mlir::Attribute attr) { … }
ModRefInfoAttr ModRefInfoAttr::get(::mlir::MLIRContext *context, ModRefInfo val) { … }
ModRefInfo ModRefInfoAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

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

::std::optional<RoundingMode> symbolizeRoundingMode(::llvm::StringRef str) { … }
bool RoundingModeAttr::classof(::mlir::Attribute attr) { … }
RoundingModeAttr RoundingModeAttr::get(::mlir::MLIRContext *context, RoundingMode val) { … }
RoundingMode RoundingModeAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
namespace tailcallkind {
::llvm::StringRef stringifyTailCallKind(TailCallKind val) { … }

::std::optional<TailCallKind> symbolizeTailCallKind(::llvm::StringRef str) { … }
::std::optional<TailCallKind> symbolizeTailCallKind(uint64_t value) { … }

bool TailCallKindAttr::classof(::mlir::Attribute attr) { … }
TailCallKindAttr TailCallKindAttr::get(::mlir::MLIRContext *context, TailCallKind val) { … }
TailCallKind TailCallKindAttr::getValue() const { … }
} // namespace tailcallkind
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyUnnamedAddr(UnnamedAddr val) { … }

::std::optional<UnnamedAddr> symbolizeUnnamedAddr(::llvm::StringRef str) { … }
::std::optional<UnnamedAddr> symbolizeUnnamedAddr(uint64_t value) { … }

bool UnnamedAddrAttr::classof(::mlir::Attribute attr) { … }
UnnamedAddrAttr UnnamedAddrAttr::get(::mlir::MLIRContext *context, UnnamedAddr val) { … }
UnnamedAddr UnnamedAddrAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir

namespace mlir {
namespace LLVM {
::llvm::StringRef stringifyVisibility(Visibility val) { … }

::std::optional<Visibility> symbolizeVisibility(::llvm::StringRef str) { … }
::std::optional<Visibility> symbolizeVisibility(uint64_t value) { … }

bool VisibilityAttr::classof(::mlir::Attribute attr) { … }
VisibilityAttr VisibilityAttr::get(::mlir::MLIRContext *context, Visibility val) { … }
Visibility VisibilityAttr::getValue() const { … }
} // namespace LLVM
} // namespace mlir
llvm/tools/mlir/include/mlir/Dialect/LLVMIR/LLVMOpsEnums.cpp.inc
