112 lines
4.7 KiB
C++
112 lines
4.7 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Enum Utility Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: EmitCAttributes.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::emitc {
|
|
|
|
::llvm::StringRef stringifyClassType(ClassType val) {
|
|
switch (val) {
|
|
case ClassType::class_: return "class";
|
|
case ClassType::struct_: return "struct";
|
|
case ClassType::union_: return "union";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ClassType> symbolizeClassType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ClassType>>(str)
|
|
.Case("class", ClassType::class_)
|
|
.Case("struct", ClassType::struct_)
|
|
.Case("union", ClassType::union_)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ClassType> symbolizeClassType(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return ClassType::class_;
|
|
case 1: return ClassType::struct_;
|
|
case 2: return ClassType::union_;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool ClassTypeAttr::classof(::mlir::Attribute attr) {
|
|
return (((::llvm::isa<::mlir::IntegerAttr>(attr))) && ((::llvm::cast<::mlir::IntegerAttr>(attr).getType().isSignlessInteger(32)))) && (((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 0)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 1)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 2)))));
|
|
}
|
|
ClassTypeAttr ClassTypeAttr::get(::mlir::MLIRContext *context, ClassType val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<ClassTypeAttr>(baseAttr);
|
|
}
|
|
ClassType ClassTypeAttr::getValue() const {
|
|
return static_cast<ClassType>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::emitc
|
|
namespace mlir::emitc {
|
|
|
|
::llvm::StringRef stringifyCmpPredicate(CmpPredicate val) {
|
|
switch (val) {
|
|
case CmpPredicate::eq: return "eq";
|
|
case CmpPredicate::ne: return "ne";
|
|
case CmpPredicate::lt: return "lt";
|
|
case CmpPredicate::le: return "le";
|
|
case CmpPredicate::gt: return "gt";
|
|
case CmpPredicate::ge: return "ge";
|
|
case CmpPredicate::three_way: return "three_way";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<CmpPredicate> symbolizeCmpPredicate(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<CmpPredicate>>(str)
|
|
.Case("eq", CmpPredicate::eq)
|
|
.Case("ne", CmpPredicate::ne)
|
|
.Case("lt", CmpPredicate::lt)
|
|
.Case("le", CmpPredicate::le)
|
|
.Case("gt", CmpPredicate::gt)
|
|
.Case("ge", CmpPredicate::ge)
|
|
.Case("three_way", CmpPredicate::three_way)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<CmpPredicate> symbolizeCmpPredicate(uint64_t value) {
|
|
switch (value) {
|
|
case 0: return CmpPredicate::eq;
|
|
case 1: return CmpPredicate::ne;
|
|
case 2: return CmpPredicate::lt;
|
|
case 3: return CmpPredicate::le;
|
|
case 4: return CmpPredicate::gt;
|
|
case 5: return CmpPredicate::ge;
|
|
case 6: return CmpPredicate::three_way;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool CmpPredicateAttr::classof(::mlir::Attribute attr) {
|
|
return (((::llvm::isa<::mlir::IntegerAttr>(attr))) && ((::llvm::cast<::mlir::IntegerAttr>(attr).getType().isSignlessInteger(64)))) && (((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 0)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 1)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 2)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 3)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 4)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 5)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(64, 6)))));
|
|
}
|
|
CmpPredicateAttr CmpPredicateAttr::get(::mlir::MLIRContext *context, CmpPredicate val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 64);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint64_t>(val));
|
|
return ::llvm::cast<CmpPredicateAttr>(baseAttr);
|
|
}
|
|
CmpPredicate CmpPredicateAttr::getValue() const {
|
|
return static_cast<CmpPredicate>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::emitc
|