456 lines
19 KiB
C++
456 lines
19 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Enum Utility Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* From: XeVMOps.td *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyAddrSpace(AddrSpace val) {
|
|
switch (val) {
|
|
case AddrSpace::PRIVATE: return "private";
|
|
case AddrSpace::GLOBAL: return "global";
|
|
case AddrSpace::CONSTANT: return "constant";
|
|
case AddrSpace::SHARED: return "shared";
|
|
case AddrSpace::GENERIC: return "generic";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<AddrSpace> symbolizeAddrSpace(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<AddrSpace>>(str)
|
|
.Case("private", AddrSpace::PRIVATE)
|
|
.Case("global", AddrSpace::GLOBAL)
|
|
.Case("constant", AddrSpace::CONSTANT)
|
|
.Case("shared", AddrSpace::SHARED)
|
|
.Case("generic", AddrSpace::GENERIC)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<AddrSpace> symbolizeAddrSpace(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return AddrSpace::PRIVATE;
|
|
case 1: return AddrSpace::GLOBAL;
|
|
case 2: return AddrSpace::CONSTANT;
|
|
case 3: return AddrSpace::SHARED;
|
|
case 4: return AddrSpace::GENERIC;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyElemType(ElemType val) {
|
|
switch (val) {
|
|
case ElemType::BF16: return "bf16";
|
|
case ElemType::F16: return "f16";
|
|
case ElemType::S8: return "s8";
|
|
case ElemType::U8: return "u8";
|
|
case ElemType::S4: return "s4";
|
|
case ElemType::U4: return "u4";
|
|
case ElemType::TF32: return "tf32";
|
|
case ElemType::F32: return "f32";
|
|
case ElemType::S32: return "s32";
|
|
case ElemType::E2M1: return "e2m1";
|
|
case ElemType::BF8: return "bf8";
|
|
case ElemType::F8: return "f8";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ElemType> symbolizeElemType(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ElemType>>(str)
|
|
.Case("bf16", ElemType::BF16)
|
|
.Case("f16", ElemType::F16)
|
|
.Case("s8", ElemType::S8)
|
|
.Case("u8", ElemType::U8)
|
|
.Case("s4", ElemType::S4)
|
|
.Case("u4", ElemType::U4)
|
|
.Case("tf32", ElemType::TF32)
|
|
.Case("f32", ElemType::F32)
|
|
.Case("s32", ElemType::S32)
|
|
.Case("e2m1", ElemType::E2M1)
|
|
.Case("bf8", ElemType::BF8)
|
|
.Case("f8", ElemType::F8)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ElemType> symbolizeElemType(uint32_t value) {
|
|
switch (value) {
|
|
case 8: return ElemType::BF16;
|
|
case 9: return ElemType::F16;
|
|
case 10: return ElemType::S8;
|
|
case 11: return ElemType::U8;
|
|
case 12: return ElemType::S4;
|
|
case 13: return ElemType::U4;
|
|
case 14: return ElemType::TF32;
|
|
case 15: return ElemType::F32;
|
|
case 16: return ElemType::S32;
|
|
case 17: return ElemType::E2M1;
|
|
case 18: return ElemType::BF8;
|
|
case 19: return ElemType::F8;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool ElemTypeAttr::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, 8)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 9)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 10)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 11)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 12)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 13)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 14)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 15)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 16)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 17)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 18)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 19)))));
|
|
}
|
|
ElemTypeAttr ElemTypeAttr::get(::mlir::MLIRContext *context, ElemType val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<ElemTypeAttr>(baseAttr);
|
|
}
|
|
ElemType ElemTypeAttr::getValue() const {
|
|
return static_cast<ElemType>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyExtfDstElemTypes(ExtfDstElemTypes val) {
|
|
switch (val) {
|
|
case ExtfDstElemTypes::F16: return "f16";
|
|
case ExtfDstElemTypes::BF16: return "bf16";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ExtfDstElemTypes> symbolizeExtfDstElemTypes(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ExtfDstElemTypes>>(str)
|
|
.Case("f16", ExtfDstElemTypes::F16)
|
|
.Case("bf16", ExtfDstElemTypes::BF16)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ExtfDstElemTypes> symbolizeExtfDstElemTypes(uint32_t value) {
|
|
switch (value) {
|
|
case 9: return ExtfDstElemTypes::F16;
|
|
case 8: return ExtfDstElemTypes::BF16;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool ExtfDstElemTypesAttr::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, 9)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 8)))));
|
|
}
|
|
ExtfDstElemTypesAttr ExtfDstElemTypesAttr::get(::mlir::MLIRContext *context, ExtfDstElemTypes val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<ExtfDstElemTypesAttr>(baseAttr);
|
|
}
|
|
ExtfDstElemTypes ExtfDstElemTypesAttr::getValue() const {
|
|
return static_cast<ExtfDstElemTypes>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyExtfSrcElemTypes(ExtfSrcElemTypes val) {
|
|
switch (val) {
|
|
case ExtfSrcElemTypes::BF8: return "bf8";
|
|
case ExtfSrcElemTypes::F8: return "f8";
|
|
case ExtfSrcElemTypes::E2M1: return "e2m1";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<ExtfSrcElemTypes> symbolizeExtfSrcElemTypes(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<ExtfSrcElemTypes>>(str)
|
|
.Case("bf8", ExtfSrcElemTypes::BF8)
|
|
.Case("f8", ExtfSrcElemTypes::F8)
|
|
.Case("e2m1", ExtfSrcElemTypes::E2M1)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<ExtfSrcElemTypes> symbolizeExtfSrcElemTypes(uint32_t value) {
|
|
switch (value) {
|
|
case 18: return ExtfSrcElemTypes::BF8;
|
|
case 19: return ExtfSrcElemTypes::F8;
|
|
case 17: return ExtfSrcElemTypes::E2M1;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool ExtfSrcElemTypesAttr::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, 18)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 19)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 17)))));
|
|
}
|
|
ExtfSrcElemTypesAttr ExtfSrcElemTypesAttr::get(::mlir::MLIRContext *context, ExtfSrcElemTypes val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<ExtfSrcElemTypesAttr>(baseAttr);
|
|
}
|
|
ExtfSrcElemTypes ExtfSrcElemTypesAttr::getValue() const {
|
|
return static_cast<ExtfSrcElemTypes>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyLoadCacheControl(LoadCacheControl val) {
|
|
switch (val) {
|
|
case LoadCacheControl::USE_DEFAULT: return "Use_Default";
|
|
case LoadCacheControl::L1UC_L2UC_L3UC: return "L1uc_L2uc_L3uc";
|
|
case LoadCacheControl::L1UC_L2UC_L3C: return "L1uc_L2uc_L3c";
|
|
case LoadCacheControl::L1UC_L2C_L3UC: return "L1uc_L2c_L3uc";
|
|
case LoadCacheControl::L1UC_L2C_L3C: return "L1uc_L2c_L3c";
|
|
case LoadCacheControl::L1C_L2UC_L3UC: return "L1c_L2uc_L3uc";
|
|
case LoadCacheControl::L1C_L2UC_L3C: return "L1c_L2uc_L3c";
|
|
case LoadCacheControl::L1C_L2C_L3UC: return "L1c_L2c_L3uc";
|
|
case LoadCacheControl::L1C_L2C_L3C: return "L1c_L2c_L3c";
|
|
case LoadCacheControl::L1S_L2UC_L3UC: return "L1s_L2uc_L3uc";
|
|
case LoadCacheControl::L1S_L2UC_L3C: return "L1s_L2uc_L3c";
|
|
case LoadCacheControl::L1S_L2C_L3UC: return "L1s_L2c_L3uc";
|
|
case LoadCacheControl::L1S_L2C_L3C: return "L1s_L2c_L3c";
|
|
case LoadCacheControl::INVALIDATE_READ: return "ir";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<LoadCacheControl> symbolizeLoadCacheControl(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<LoadCacheControl>>(str)
|
|
.Case("Use_Default", LoadCacheControl::USE_DEFAULT)
|
|
.Case("L1uc_L2uc_L3uc", LoadCacheControl::L1UC_L2UC_L3UC)
|
|
.Case("L1uc_L2uc_L3c", LoadCacheControl::L1UC_L2UC_L3C)
|
|
.Case("L1uc_L2c_L3uc", LoadCacheControl::L1UC_L2C_L3UC)
|
|
.Case("L1uc_L2c_L3c", LoadCacheControl::L1UC_L2C_L3C)
|
|
.Case("L1c_L2uc_L3uc", LoadCacheControl::L1C_L2UC_L3UC)
|
|
.Case("L1c_L2uc_L3c", LoadCacheControl::L1C_L2UC_L3C)
|
|
.Case("L1c_L2c_L3uc", LoadCacheControl::L1C_L2C_L3UC)
|
|
.Case("L1c_L2c_L3c", LoadCacheControl::L1C_L2C_L3C)
|
|
.Case("L1s_L2uc_L3uc", LoadCacheControl::L1S_L2UC_L3UC)
|
|
.Case("L1s_L2uc_L3c", LoadCacheControl::L1S_L2UC_L3C)
|
|
.Case("L1s_L2c_L3uc", LoadCacheControl::L1S_L2C_L3UC)
|
|
.Case("L1s_L2c_L3c", LoadCacheControl::L1S_L2C_L3C)
|
|
.Case("ir", LoadCacheControl::INVALIDATE_READ)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<LoadCacheControl> symbolizeLoadCacheControl(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return LoadCacheControl::USE_DEFAULT;
|
|
case 1: return LoadCacheControl::L1UC_L2UC_L3UC;
|
|
case 2: return LoadCacheControl::L1UC_L2UC_L3C;
|
|
case 3: return LoadCacheControl::L1UC_L2C_L3UC;
|
|
case 4: return LoadCacheControl::L1UC_L2C_L3C;
|
|
case 5: return LoadCacheControl::L1C_L2UC_L3UC;
|
|
case 6: return LoadCacheControl::L1C_L2UC_L3C;
|
|
case 7: return LoadCacheControl::L1C_L2C_L3UC;
|
|
case 8: return LoadCacheControl::L1C_L2C_L3C;
|
|
case 9: return LoadCacheControl::L1S_L2UC_L3UC;
|
|
case 10: return LoadCacheControl::L1S_L2UC_L3C;
|
|
case 11: return LoadCacheControl::L1S_L2C_L3UC;
|
|
case 12: return LoadCacheControl::L1S_L2C_L3C;
|
|
case 13: return LoadCacheControl::INVALIDATE_READ;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyMemScope(MemScope val) {
|
|
switch (val) {
|
|
case MemScope::LANE: return "lane";
|
|
case MemScope::SUBGROUP: return "subgroup";
|
|
case MemScope::WORKGROUP: return "workgroup";
|
|
case MemScope::CLUSTER: return "cluster";
|
|
case MemScope::DEVICE: return "device";
|
|
case MemScope::SYSTEM: return "system";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<MemScope> symbolizeMemScope(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<MemScope>>(str)
|
|
.Case("lane", MemScope::LANE)
|
|
.Case("subgroup", MemScope::SUBGROUP)
|
|
.Case("workgroup", MemScope::WORKGROUP)
|
|
.Case("cluster", MemScope::CLUSTER)
|
|
.Case("device", MemScope::DEVICE)
|
|
.Case("system", MemScope::SYSTEM)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<MemScope> symbolizeMemScope(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return MemScope::LANE;
|
|
case 1: return MemScope::SUBGROUP;
|
|
case 2: return MemScope::WORKGROUP;
|
|
case 3: return MemScope::CLUSTER;
|
|
case 4: return MemScope::DEVICE;
|
|
case 5: return MemScope::SYSTEM;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyStoreCacheControl(StoreCacheControl val) {
|
|
switch (val) {
|
|
case StoreCacheControl::USE_DEFAULT: return "Use_Default";
|
|
case StoreCacheControl::L1UC_L2UC_L3UC: return "L1uc_L2uc_L3uc";
|
|
case StoreCacheControl::L1UC_L2UC_L3WB: return "L1uc_L2uc_L3wb";
|
|
case StoreCacheControl::L1UC_L2WB_L3UC: return "L1uc_L2wb_L3uc";
|
|
case StoreCacheControl::L1UC_L2WB_L3WB: return "L1uc_L2wb_L3wb";
|
|
case StoreCacheControl::L1WT_L2UC_L3UC: return "L1wt_L2uc_L3uc";
|
|
case StoreCacheControl::L1WT_L2UC_L3WB: return "L1wt_L2uc_L3wb";
|
|
case StoreCacheControl::L1WT_L2WB_L3UC: return "L1wt_L2wb_L3uc";
|
|
case StoreCacheControl::L1WT_L2WB_L3WB: return "L1wt_L2wb_L3wb";
|
|
case StoreCacheControl::L1S_L2UC_L3UC: return "L1s_L2uc_L3uc";
|
|
case StoreCacheControl::L1S_L2UC_L3WB: return "L1s_L2uc_L3wb";
|
|
case StoreCacheControl::L1S_L2WB_L3UC: return "L1s_L2wb_L3uc";
|
|
case StoreCacheControl::L1S_L2WB_L3WB: return "L1s_L2wb_L3wb";
|
|
case StoreCacheControl::L1WB_L2UC_L3UC: return "L1wb_L2uc_L3uc";
|
|
case StoreCacheControl::L1WB_L2WB_L3UC: return "L1wb_L2wb_L3uc";
|
|
case StoreCacheControl::L1WB_L2UC_L3WB: return "L1wb_L2uc_L3wb";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<StoreCacheControl> symbolizeStoreCacheControl(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<StoreCacheControl>>(str)
|
|
.Case("Use_Default", StoreCacheControl::USE_DEFAULT)
|
|
.Case("L1uc_L2uc_L3uc", StoreCacheControl::L1UC_L2UC_L3UC)
|
|
.Case("L1uc_L2uc_L3wb", StoreCacheControl::L1UC_L2UC_L3WB)
|
|
.Case("L1uc_L2wb_L3uc", StoreCacheControl::L1UC_L2WB_L3UC)
|
|
.Case("L1uc_L2wb_L3wb", StoreCacheControl::L1UC_L2WB_L3WB)
|
|
.Case("L1wt_L2uc_L3uc", StoreCacheControl::L1WT_L2UC_L3UC)
|
|
.Case("L1wt_L2uc_L3wb", StoreCacheControl::L1WT_L2UC_L3WB)
|
|
.Case("L1wt_L2wb_L3uc", StoreCacheControl::L1WT_L2WB_L3UC)
|
|
.Case("L1wt_L2wb_L3wb", StoreCacheControl::L1WT_L2WB_L3WB)
|
|
.Case("L1s_L2uc_L3uc", StoreCacheControl::L1S_L2UC_L3UC)
|
|
.Case("L1s_L2uc_L3wb", StoreCacheControl::L1S_L2UC_L3WB)
|
|
.Case("L1s_L2wb_L3uc", StoreCacheControl::L1S_L2WB_L3UC)
|
|
.Case("L1s_L2wb_L3wb", StoreCacheControl::L1S_L2WB_L3WB)
|
|
.Case("L1wb_L2uc_L3uc", StoreCacheControl::L1WB_L2UC_L3UC)
|
|
.Case("L1wb_L2wb_L3uc", StoreCacheControl::L1WB_L2WB_L3UC)
|
|
.Case("L1wb_L2uc_L3wb", StoreCacheControl::L1WB_L2UC_L3WB)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<StoreCacheControl> symbolizeStoreCacheControl(uint32_t value) {
|
|
switch (value) {
|
|
case 0: return StoreCacheControl::USE_DEFAULT;
|
|
case 1: return StoreCacheControl::L1UC_L2UC_L3UC;
|
|
case 2: return StoreCacheControl::L1UC_L2UC_L3WB;
|
|
case 3: return StoreCacheControl::L1UC_L2WB_L3UC;
|
|
case 4: return StoreCacheControl::L1UC_L2WB_L3WB;
|
|
case 5: return StoreCacheControl::L1WT_L2UC_L3UC;
|
|
case 6: return StoreCacheControl::L1WT_L2UC_L3WB;
|
|
case 7: return StoreCacheControl::L1WT_L2WB_L3UC;
|
|
case 8: return StoreCacheControl::L1WT_L2WB_L3WB;
|
|
case 9: return StoreCacheControl::L1S_L2UC_L3UC;
|
|
case 10: return StoreCacheControl::L1S_L2UC_L3WB;
|
|
case 11: return StoreCacheControl::L1S_L2WB_L3UC;
|
|
case 12: return StoreCacheControl::L1S_L2WB_L3WB;
|
|
case 13: return StoreCacheControl::L1WB_L2UC_L3UC;
|
|
case 14: return StoreCacheControl::L1WB_L2WB_L3UC;
|
|
case 15: return StoreCacheControl::L1WB_L2UC_L3WB;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyTruncfDstElemTypes(TruncfDstElemTypes val) {
|
|
switch (val) {
|
|
case TruncfDstElemTypes::BF8: return "bf8";
|
|
case TruncfDstElemTypes::F8: return "f8";
|
|
case TruncfDstElemTypes::E2M1: return "e2m1";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<TruncfDstElemTypes> symbolizeTruncfDstElemTypes(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<TruncfDstElemTypes>>(str)
|
|
.Case("bf8", TruncfDstElemTypes::BF8)
|
|
.Case("f8", TruncfDstElemTypes::F8)
|
|
.Case("e2m1", TruncfDstElemTypes::E2M1)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<TruncfDstElemTypes> symbolizeTruncfDstElemTypes(uint32_t value) {
|
|
switch (value) {
|
|
case 18: return TruncfDstElemTypes::BF8;
|
|
case 19: return TruncfDstElemTypes::F8;
|
|
case 17: return TruncfDstElemTypes::E2M1;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool TruncfDstElemTypesAttr::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, 18)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 19)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 17)))));
|
|
}
|
|
TruncfDstElemTypesAttr TruncfDstElemTypesAttr::get(::mlir::MLIRContext *context, TruncfDstElemTypes val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<TruncfDstElemTypesAttr>(baseAttr);
|
|
}
|
|
TruncfDstElemTypes TruncfDstElemTypesAttr::getValue() const {
|
|
return static_cast<TruncfDstElemTypes>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::xevm
|
|
namespace mlir::xevm {
|
|
|
|
::llvm::StringRef stringifyTruncfSrcElemTypes(TruncfSrcElemTypes val) {
|
|
switch (val) {
|
|
case TruncfSrcElemTypes::F16: return "f16";
|
|
case TruncfSrcElemTypes::BF16: return "bf16";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
::std::optional<TruncfSrcElemTypes> symbolizeTruncfSrcElemTypes(::llvm::StringRef str) {
|
|
return ::llvm::StringSwitch<::std::optional<TruncfSrcElemTypes>>(str)
|
|
.Case("f16", TruncfSrcElemTypes::F16)
|
|
.Case("bf16", TruncfSrcElemTypes::BF16)
|
|
.Default(::std::nullopt);
|
|
}
|
|
::std::optional<TruncfSrcElemTypes> symbolizeTruncfSrcElemTypes(uint32_t value) {
|
|
switch (value) {
|
|
case 9: return TruncfSrcElemTypes::F16;
|
|
case 8: return TruncfSrcElemTypes::BF16;
|
|
default: return ::std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool TruncfSrcElemTypesAttr::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, 9)))) || ((
|
|
::llvm::cast<::mlir::IntegerAttr>(attr).getValue().eq(::llvm::APInt(32, 8)))));
|
|
}
|
|
TruncfSrcElemTypesAttr TruncfSrcElemTypesAttr::get(::mlir::MLIRContext *context, TruncfSrcElemTypes val) {
|
|
::mlir::IntegerType intType = ::mlir::IntegerType::get(context, 32);
|
|
::mlir::IntegerAttr baseAttr = ::mlir::IntegerAttr::get(intType, static_cast<uint32_t>(val));
|
|
return ::llvm::cast<TruncfSrcElemTypesAttr>(baseAttr);
|
|
}
|
|
TruncfSrcElemTypes TruncfSrcElemTypesAttr::getValue() const {
|
|
return static_cast<TruncfSrcElemTypes>(::mlir::IntegerAttr::getValue().getZExtValue());
|
|
}
|
|
|
|
} // namespace mlir::xevm
|