199 lines
6.7 KiB
C++
199 lines
6.7 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Enum Utility Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: PtrOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::ptr {
|
|
|
|
::llvm::StringRef stringifyAtomicBinOp(AtomicBinOp val) {
|
|
switch (val) {
|
|
case AtomicBinOp::xchg: return "xchg";
|
|
case AtomicBinOp::add: return "add";
|
|
case AtomicBinOp::sub: return "sub";
|
|
case AtomicBinOp::_and: return "_and";
|
|
case AtomicBinOp::nand: return "nand";
|
|
case AtomicBinOp::_or: return "_or";
|
|
case AtomicBinOp::_xor: return "_xor";
|
|
case AtomicBinOp::max: return "max";
|
|
case AtomicBinOp::min: return "min";
|
|
case AtomicBinOp::umax: return "umax";
|
|
case AtomicBinOp::umin: return "umin";
|
|
case AtomicBinOp::fadd: return "fadd";
|
|
case AtomicBinOp::fsub: return "fsub";
|
|
case AtomicBinOp::fmax: return "fmax";
|
|
case AtomicBinOp::fmin: return "fmin";
|
|
case AtomicBinOp::uinc_wrap: return "uinc_wrap";
|
|
case AtomicBinOp::udec_wrap: return "udec_wrap";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<AtomicBinOp> symbolizeAtomicBinOp(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<AtomicBinOp>>(str)
|
|
.Case("xchg", AtomicBinOp::xchg)
|
|
.Case("add", AtomicBinOp::add)
|
|
.Case("sub", AtomicBinOp::sub)
|
|
.Case("_and", AtomicBinOp::_and)
|
|
.Case("nand", AtomicBinOp::nand)
|
|
.Case("_or", AtomicBinOp::_or)
|
|
.Case("_xor", AtomicBinOp::_xor)
|
|
.Case("max", AtomicBinOp::max)
|
|
.Case("min", AtomicBinOp::min)
|
|
.Case("umax", AtomicBinOp::umax)
|
|
.Case("umin", AtomicBinOp::umin)
|
|
.Case("fadd", AtomicBinOp::fadd)
|
|
.Case("fsub", AtomicBinOp::fsub)
|
|
.Case("fmax", AtomicBinOp::fmax)
|
|
.Case("fmin", AtomicBinOp::fmin)
|
|
.Case("uinc_wrap", AtomicBinOp::uinc_wrap)
|
|
.Case("udec_wrap", AtomicBinOp::udec_wrap)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<AtomicBinOp> symbolizeAtomicBinOp(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return AtomicBinOp::xchg;
|
|
case 1: return AtomicBinOp::add;
|
|
case 2: return AtomicBinOp::sub;
|
|
case 3: return AtomicBinOp::_and;
|
|
case 4: return AtomicBinOp::nand;
|
|
case 5: return AtomicBinOp::_or;
|
|
case 6: return AtomicBinOp::_xor;
|
|
case 7: return AtomicBinOp::max;
|
|
case 8: return AtomicBinOp::min;
|
|
case 9: return AtomicBinOp::umax;
|
|
case 10: return AtomicBinOp::umin;
|
|
case 11: return AtomicBinOp::fadd;
|
|
case 12: return AtomicBinOp::fsub;
|
|
case 13: return AtomicBinOp::fmax;
|
|
case 14: return AtomicBinOp::fmin;
|
|
case 15: return AtomicBinOp::uinc_wrap;
|
|
case 16: return AtomicBinOp::udec_wrap;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::ptr
|
|
namespace mlir::ptr {
|
|
|
|
::llvm::StringRef stringifyAtomicOrdering(AtomicOrdering val) {
|
|
switch (val) {
|
|
case AtomicOrdering::not_atomic: return "not_atomic";
|
|
case AtomicOrdering::unordered: return "unordered";
|
|
case AtomicOrdering::monotonic: return "monotonic";
|
|
case AtomicOrdering::acquire: return "acquire";
|
|
case AtomicOrdering::release: return "release";
|
|
case AtomicOrdering::acq_rel: return "acq_rel";
|
|
case AtomicOrdering::seq_cst: return "seq_cst";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<AtomicOrdering> symbolizeAtomicOrdering(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<AtomicOrdering>>(str)
|
|
.Case("not_atomic", AtomicOrdering::not_atomic)
|
|
.Case("unordered", AtomicOrdering::unordered)
|
|
.Case("monotonic", AtomicOrdering::monotonic)
|
|
.Case("acquire", AtomicOrdering::acquire)
|
|
.Case("release", AtomicOrdering::release)
|
|
.Case("acq_rel", AtomicOrdering::acq_rel)
|
|
.Case("seq_cst", AtomicOrdering::seq_cst)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<AtomicOrdering> symbolizeAtomicOrdering(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return AtomicOrdering::not_atomic;
|
|
case 1: return AtomicOrdering::unordered;
|
|
case 2: return AtomicOrdering::monotonic;
|
|
case 3: return AtomicOrdering::acquire;
|
|
case 4: return AtomicOrdering::release;
|
|
case 5: return AtomicOrdering::acq_rel;
|
|
case 6: return AtomicOrdering::seq_cst;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::ptr
|
|
namespace mlir::ptr {
|
|
|
|
::llvm::StringRef stringifyPtrAddFlags(PtrAddFlags val) {
|
|
switch (val) {
|
|
case PtrAddFlags::none: return "none";
|
|
case PtrAddFlags::nusw: return "nusw";
|
|
case PtrAddFlags::nuw: return "nuw";
|
|
case PtrAddFlags::inbounds: return "inbounds";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<PtrAddFlags> symbolizePtrAddFlags(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<PtrAddFlags>>(str)
|
|
.Case("none", PtrAddFlags::none)
|
|
.Case("nusw", PtrAddFlags::nusw)
|
|
.Case("nuw", PtrAddFlags::nuw)
|
|
.Case("inbounds", PtrAddFlags::inbounds)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<PtrAddFlags> symbolizePtrAddFlags(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return PtrAddFlags::none;
|
|
case 1: return PtrAddFlags::nusw;
|
|
case 2: return PtrAddFlags::nuw;
|
|
case 3: return PtrAddFlags::inbounds;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::ptr
|
|
namespace mlir::ptr {
|
|
|
|
std::string stringifyPtrDiffFlags(PtrDiffFlags symbol) {
|
|
auto val = static_cast<uint8_t>(symbol);
|
|
assert(3u == (3u | val) && "invalid bits set in bit enum");
|
|
// Special case for all bits unset.
|
|
if (val == 0) return "none";
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> strs;
|
|
|
|
if (1u == (1u & val))
|
|
strs.push_back("nuw");
|
|
|
|
if (2u == (2u & val))
|
|
strs.push_back("nsw");
|
|
return ::llvm::join(strs, "|");
|
|
}
|
|
|
|
::std::optional<PtrDiffFlags> symbolizePtrDiffFlags(::llvm::StringRef str) {
|
|
// Special case for all bits unset.
|
|
if (str == "none") return PtrDiffFlags::none;
|
|
|
|
::llvm::SmallVector<::llvm::StringRef, 2> symbols;
|
|
str.split(symbols, "|");
|
|
|
|
uint8_t val = 0;
|
|
for (auto symbol : symbols) {
|
|
auto bit = llvm::StringSwitch<::std::optional<uint8_t>>(symbol.trim())
|
|
.Case("nuw", 1)
|
|
.Case("nsw", 2)
|
|
.Default(::std::nullopt);
|
|
if (bit) { val |= *bit; } else { return ::std::nullopt; }
|
|
}
|
|
return static_cast<PtrDiffFlags>(val);
|
|
}
|
|
|
|
::std::optional<PtrDiffFlags> symbolizePtrDiffFlags(uint8_t value) {
|
|
// Special case for all bits unset.
|
|
if (value == 0) return PtrDiffFlags::none;
|
|
|
|
if (value & ~static_cast<uint8_t>(3u)) return std::nullopt;
|
|
return static_cast<PtrDiffFlags>(value);
|
|
}
|
|
|
|
} // namespace mlir::ptr
|