1138 lines
46 KiB
C++
1138 lines
46 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* AttrDef Declarations *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
#ifdef GET_ATTRDEF_CLASSES
|
|
#undef GET_ATTRDEF_CLASSES
|
|
|
|
|
|
namespace mlir {
|
|
class AsmParser;
|
|
class AsmPrinter;
|
|
} // namespace mlir
|
|
namespace mlir::spirv {
|
|
|
|
/// valid SPIR-V version
|
|
class VersionAttr;
|
|
/// valid SPIR-V device types
|
|
class DeviceTypeAttr;
|
|
/// recognized SPIR-V vendor strings
|
|
class VendorAttr;
|
|
/// recognized SPIR-V client APIs
|
|
class ClientAPIAttr;
|
|
/// supported SPIR-V extensions
|
|
class ExtensionAttr;
|
|
/// valid SPIR-V Capability
|
|
class CapabilityAttr;
|
|
/// valid SPIR-V AddressingModel
|
|
class AddressingModelAttr;
|
|
/// valid SPIR-V BuiltIn
|
|
class BuiltInAttr;
|
|
/// valid SPIR-V Decoration
|
|
class DecorationAttr;
|
|
/// valid SPIR-V Dim
|
|
class DimAttr;
|
|
/// valid SPIR-V ExecutionMode
|
|
class ExecutionModeAttr;
|
|
/// valid SPIR-V ExecutionModel
|
|
class ExecutionModelAttr;
|
|
/// valid SPIR-V FPEncoding
|
|
class FPEncodingAttr;
|
|
/// valid SPIR-V FPRoundingMode
|
|
class FPRoundingModeAttr;
|
|
/// valid SPIR-V FunctionControl
|
|
class FunctionControlAttr;
|
|
/// valid SPIR-V GroupOperation
|
|
class GroupOperationAttr;
|
|
/// valid SPIR-V ImageFormat
|
|
class ImageFormatAttr;
|
|
/// valid SPIR-V ImageOperands
|
|
class ImageOperandsAttr;
|
|
/// valid SPIR-V LinkageType
|
|
class LinkageTypeAttr;
|
|
/// valid SPIR-V LoopControl
|
|
class LoopControlAttr;
|
|
/// valid SPIR-V MemoryAccess
|
|
class MemoryAccessAttr;
|
|
/// valid SPIR-V MemoryModel
|
|
class MemoryModelAttr;
|
|
/// valid SPIR-V MemorySemantics
|
|
class MemorySemanticsAttr;
|
|
/// valid SPIR-V Scope
|
|
class ScopeAttr;
|
|
/// valid SPIR-V SelectionControl
|
|
class SelectionControlAttr;
|
|
/// valid SPIR-V StorageClass
|
|
class StorageClassAttr;
|
|
/// valid SPIR-V PackedVectorFormat
|
|
class PackedVectorFormatAttr;
|
|
/// valid SPIR-V Image Depth specification
|
|
class ImageDepthInfoAttr;
|
|
/// valid SPIR-V Image Arrayed specification
|
|
class ImageArrayedInfoAttr;
|
|
/// valid SPIR-V Image Sampling specification
|
|
class ImageSamplingInfoAttr;
|
|
/// valid SPIR-V Sampler Use specification
|
|
class ImageSamplerUseInfoAttr;
|
|
/// valid SPIR-V MatrixLayout
|
|
class MatrixLayoutAttr;
|
|
/// valid SPIR-V Cooperative Matrix Use (KHR)
|
|
class CooperativeMatrixUseKHRAttr;
|
|
/// valid SPIR-V Cooperative Matrix Layout (KHR)
|
|
class CooperativeMatrixLayoutKHRAttr;
|
|
/// valid SPIR-V Cooperative Matrix Operands (KHR)
|
|
class CooperativeMatrixOperandsKHRAttr;
|
|
/// valid SPIR-V LoadCacheControl
|
|
class LoadCacheControlAttr;
|
|
/// valid SPIR-V StoreCacheControl
|
|
class StoreCacheControlAttr;
|
|
/// Swap direction of a GroupNonUniformQuadSwap
|
|
class QuadSwapDirectionAttr;
|
|
/// valid SPIR-V instructions
|
|
class OpcodeAttr;
|
|
/// Indicates a floating-point fast math flag
|
|
class FPFastMathModeAttr;
|
|
/// Tosa Ext Acculumator Type
|
|
class TosaExtAccTypeAttr;
|
|
/// Tosa Ext Resize Mode Type
|
|
class TosaExtResizeModeTypeAttr;
|
|
/// Tosa Ext NaN Propoagation Mode Type
|
|
class TosaExtNaNPropagationModeTypeAttr;
|
|
/// Tosa Ext Rounding Mode Type
|
|
class TosaExtRoundingModeTypeAttr;
|
|
class EntryPointABIAttr;
|
|
class LinkageAttributesAttr;
|
|
class CooperativeMatrixPropertiesKHRAttr;
|
|
class CacheControlLoadINTELAttr;
|
|
class CacheControlStoreINTELAttr;
|
|
class ResourceLimitsAttr;
|
|
namespace detail {
|
|
|
|
struct VersionAttrStorage;
|
|
|
|
} // namespace detail
|
|
class VersionAttr : public ::mlir::Attribute::AttrBase<VersionAttr, ::mlir::Attribute, detail::VersionAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.version";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static VersionAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Version value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"version"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Version getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct DeviceTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DeviceTypeAttr : public ::mlir::Attribute::AttrBase<DeviceTypeAttr, ::mlir::Attribute, detail::DeviceTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.device_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static DeviceTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::DeviceType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"device_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::DeviceType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct VendorAttrStorage;
|
|
|
|
} // namespace detail
|
|
class VendorAttr : public ::mlir::Attribute::AttrBase<VendorAttr, ::mlir::Attribute, detail::VendorAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.vendor";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static VendorAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Vendor value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"vendor"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Vendor getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ClientAPIAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ClientAPIAttr : public ::mlir::Attribute::AttrBase<ClientAPIAttr, ::mlir::Attribute, detail::ClientAPIAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.client_api";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ClientAPIAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ClientAPI value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"client_api"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ClientAPI getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ExtensionAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ExtensionAttr : public ::mlir::Attribute::AttrBase<ExtensionAttr, ::mlir::Attribute, detail::ExtensionAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.ext";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ExtensionAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Extension value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"ext"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Extension getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CapabilityAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CapabilityAttr : public ::mlir::Attribute::AttrBase<CapabilityAttr, ::mlir::Attribute, detail::CapabilityAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.capability";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CapabilityAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Capability value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"capability"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Capability getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct AddressingModelAttrStorage;
|
|
|
|
} // namespace detail
|
|
class AddressingModelAttr : public ::mlir::Attribute::AttrBase<AddressingModelAttr, ::mlir::Attribute, detail::AddressingModelAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.addressing_model";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static AddressingModelAttr get(::mlir::MLIRContext *context, ::mlir::spirv::AddressingModel value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"addressing_model"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::AddressingModel getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct BuiltInAttrStorage;
|
|
|
|
} // namespace detail
|
|
class BuiltInAttr : public ::mlir::Attribute::AttrBase<BuiltInAttr, ::mlir::Attribute, detail::BuiltInAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.built_in";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static BuiltInAttr get(::mlir::MLIRContext *context, ::mlir::spirv::BuiltIn value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"built_in"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::BuiltIn getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct DecorationAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DecorationAttr : public ::mlir::Attribute::AttrBase<DecorationAttr, ::mlir::Attribute, detail::DecorationAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.decoration";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static DecorationAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Decoration value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"decoration"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Decoration getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct DimAttrStorage;
|
|
|
|
} // namespace detail
|
|
class DimAttr : public ::mlir::Attribute::AttrBase<DimAttr, ::mlir::Attribute, detail::DimAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.dim";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static DimAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Dim value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"dim"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Dim getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ExecutionModeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ExecutionModeAttr : public ::mlir::Attribute::AttrBase<ExecutionModeAttr, ::mlir::Attribute, detail::ExecutionModeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.execution_mode";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ExecutionModeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ExecutionMode value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"execution_mode"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ExecutionMode getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ExecutionModelAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ExecutionModelAttr : public ::mlir::Attribute::AttrBase<ExecutionModelAttr, ::mlir::Attribute, detail::ExecutionModelAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.execution_model";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ExecutionModelAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ExecutionModel value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"execution_model"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ExecutionModel getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct FPEncodingAttrStorage;
|
|
|
|
} // namespace detail
|
|
class FPEncodingAttr : public ::mlir::Attribute::AttrBase<FPEncodingAttr, ::mlir::Attribute, detail::FPEncodingAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.f_p_encoding";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static FPEncodingAttr get(::mlir::MLIRContext *context, ::mlir::spirv::FPEncoding value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"f_p_encoding"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::FPEncoding getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct FPRoundingModeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class FPRoundingModeAttr : public ::mlir::Attribute::AttrBase<FPRoundingModeAttr, ::mlir::Attribute, detail::FPRoundingModeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.fp_rounding_mode";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static FPRoundingModeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::FPRoundingMode value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"fp_rounding_mode"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::FPRoundingMode getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct FunctionControlAttrStorage;
|
|
|
|
} // namespace detail
|
|
class FunctionControlAttr : public ::mlir::Attribute::AttrBase<FunctionControlAttr, ::mlir::Attribute, detail::FunctionControlAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.function_control";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static FunctionControlAttr get(::mlir::MLIRContext *context, ::mlir::spirv::FunctionControl value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"function_control"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::FunctionControl getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct GroupOperationAttrStorage;
|
|
|
|
} // namespace detail
|
|
class GroupOperationAttr : public ::mlir::Attribute::AttrBase<GroupOperationAttr, ::mlir::Attribute, detail::GroupOperationAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.group_operation";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static GroupOperationAttr get(::mlir::MLIRContext *context, ::mlir::spirv::GroupOperation value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"group_operation"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::GroupOperation getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageFormatAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageFormatAttr : public ::mlir::Attribute::AttrBase<ImageFormatAttr, ::mlir::Attribute, detail::ImageFormatAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_format";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageFormatAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageFormat value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_format"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageFormat getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageOperandsAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageOperandsAttr : public ::mlir::Attribute::AttrBase<ImageOperandsAttr, ::mlir::Attribute, detail::ImageOperandsAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_operands";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageOperandsAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageOperands value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_operands"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageOperands getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct LinkageTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class LinkageTypeAttr : public ::mlir::Attribute::AttrBase<LinkageTypeAttr, ::mlir::Attribute, detail::LinkageTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.linkage_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static LinkageTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::LinkageType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"linkage_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::LinkageType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct LoopControlAttrStorage;
|
|
|
|
} // namespace detail
|
|
class LoopControlAttr : public ::mlir::Attribute::AttrBase<LoopControlAttr, ::mlir::Attribute, detail::LoopControlAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.loop_control";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static LoopControlAttr get(::mlir::MLIRContext *context, ::mlir::spirv::LoopControl value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"loop_control"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::LoopControl getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct MemoryAccessAttrStorage;
|
|
|
|
} // namespace detail
|
|
class MemoryAccessAttr : public ::mlir::Attribute::AttrBase<MemoryAccessAttr, ::mlir::Attribute, detail::MemoryAccessAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.memory_access";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static MemoryAccessAttr get(::mlir::MLIRContext *context, ::mlir::spirv::MemoryAccess value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"memory_access"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::MemoryAccess getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct MemoryModelAttrStorage;
|
|
|
|
} // namespace detail
|
|
class MemoryModelAttr : public ::mlir::Attribute::AttrBase<MemoryModelAttr, ::mlir::Attribute, detail::MemoryModelAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.memory_model";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static MemoryModelAttr get(::mlir::MLIRContext *context, ::mlir::spirv::MemoryModel value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"memory_model"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::MemoryModel getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct MemorySemanticsAttrStorage;
|
|
|
|
} // namespace detail
|
|
class MemorySemanticsAttr : public ::mlir::Attribute::AttrBase<MemorySemanticsAttr, ::mlir::Attribute, detail::MemorySemanticsAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.memory_semantics";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static MemorySemanticsAttr get(::mlir::MLIRContext *context, ::mlir::spirv::MemorySemantics value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"memory_semantics"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::MemorySemantics getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ScopeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ScopeAttr : public ::mlir::Attribute::AttrBase<ScopeAttr, ::mlir::Attribute, detail::ScopeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.scope";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ScopeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Scope value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"scope"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Scope getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct SelectionControlAttrStorage;
|
|
|
|
} // namespace detail
|
|
class SelectionControlAttr : public ::mlir::Attribute::AttrBase<SelectionControlAttr, ::mlir::Attribute, detail::SelectionControlAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.selection_control";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static SelectionControlAttr get(::mlir::MLIRContext *context, ::mlir::spirv::SelectionControl value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"selection_control"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::SelectionControl getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct StorageClassAttrStorage;
|
|
|
|
} // namespace detail
|
|
class StorageClassAttr : public ::mlir::Attribute::AttrBase<StorageClassAttr, ::mlir::Attribute, detail::StorageClassAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.storage_class";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static StorageClassAttr get(::mlir::MLIRContext *context, ::mlir::spirv::StorageClass value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"storage_class"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::StorageClass getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct PackedVectorFormatAttrStorage;
|
|
|
|
} // namespace detail
|
|
class PackedVectorFormatAttr : public ::mlir::Attribute::AttrBase<PackedVectorFormatAttr, ::mlir::Attribute, detail::PackedVectorFormatAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.packed_vector_format";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static PackedVectorFormatAttr get(::mlir::MLIRContext *context, ::mlir::spirv::PackedVectorFormat value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"packed_vector_format"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::PackedVectorFormat getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageDepthInfoAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageDepthInfoAttr : public ::mlir::Attribute::AttrBase<ImageDepthInfoAttr, ::mlir::Attribute, detail::ImageDepthInfoAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_depth_info";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageDepthInfoAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageDepthInfo value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_depth_info"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageDepthInfo getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageArrayedInfoAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageArrayedInfoAttr : public ::mlir::Attribute::AttrBase<ImageArrayedInfoAttr, ::mlir::Attribute, detail::ImageArrayedInfoAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_arrayed_info";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageArrayedInfoAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageArrayedInfo value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_arrayed_info"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageArrayedInfo getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageSamplingInfoAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageSamplingInfoAttr : public ::mlir::Attribute::AttrBase<ImageSamplingInfoAttr, ::mlir::Attribute, detail::ImageSamplingInfoAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_sampling_info";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageSamplingInfoAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageSamplingInfo value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_sampling_info"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageSamplingInfo getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ImageSamplerUseInfoAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ImageSamplerUseInfoAttr : public ::mlir::Attribute::AttrBase<ImageSamplerUseInfoAttr, ::mlir::Attribute, detail::ImageSamplerUseInfoAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.image_sampler_use_info";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ImageSamplerUseInfoAttr get(::mlir::MLIRContext *context, ::mlir::spirv::ImageSamplerUseInfo value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"image_sampler_use_info"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::ImageSamplerUseInfo getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct MatrixLayoutAttrStorage;
|
|
|
|
} // namespace detail
|
|
class MatrixLayoutAttr : public ::mlir::Attribute::AttrBase<MatrixLayoutAttr, ::mlir::Attribute, detail::MatrixLayoutAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.matrixLayout";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static MatrixLayoutAttr get(::mlir::MLIRContext *context, ::mlir::spirv::MatrixLayout value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"matrixLayout"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::MatrixLayout getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CooperativeMatrixUseKHRAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CooperativeMatrixUseKHRAttr : public ::mlir::Attribute::AttrBase<CooperativeMatrixUseKHRAttr, ::mlir::Attribute, detail::CooperativeMatrixUseKHRAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.coop_matrix_use_khr";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CooperativeMatrixUseKHRAttr get(::mlir::MLIRContext *context, ::mlir::spirv::CooperativeMatrixUseKHR value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"coop_matrix_use_khr"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::CooperativeMatrixUseKHR getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CooperativeMatrixLayoutKHRAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CooperativeMatrixLayoutKHRAttr : public ::mlir::Attribute::AttrBase<CooperativeMatrixLayoutKHRAttr, ::mlir::Attribute, detail::CooperativeMatrixLayoutKHRAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.coop_matrix_layout_khr";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CooperativeMatrixLayoutKHRAttr get(::mlir::MLIRContext *context, ::mlir::spirv::CooperativeMatrixLayoutKHR value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"coop_matrix_layout_khr"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::CooperativeMatrixLayoutKHR getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CooperativeMatrixOperandsKHRAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CooperativeMatrixOperandsKHRAttr : public ::mlir::Attribute::AttrBase<CooperativeMatrixOperandsKHRAttr, ::mlir::Attribute, detail::CooperativeMatrixOperandsKHRAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.cooperative_matrix_operands_khr";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CooperativeMatrixOperandsKHRAttr get(::mlir::MLIRContext *context, ::mlir::spirv::CooperativeMatrixOperandsKHR value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"cooperative_matrix_operands_khr"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::CooperativeMatrixOperandsKHR getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct LoadCacheControlAttrStorage;
|
|
|
|
} // namespace detail
|
|
class LoadCacheControlAttr : public ::mlir::Attribute::AttrBase<LoadCacheControlAttr, ::mlir::Attribute, detail::LoadCacheControlAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.load_cache_control";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static LoadCacheControlAttr get(::mlir::MLIRContext *context, ::mlir::spirv::LoadCacheControl value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"load_cache_control"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::LoadCacheControl getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct StoreCacheControlAttrStorage;
|
|
|
|
} // namespace detail
|
|
class StoreCacheControlAttr : public ::mlir::Attribute::AttrBase<StoreCacheControlAttr, ::mlir::Attribute, detail::StoreCacheControlAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.store_cache_control";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static StoreCacheControlAttr get(::mlir::MLIRContext *context, ::mlir::spirv::StoreCacheControl value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"store_cache_control"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::StoreCacheControl getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct QuadSwapDirectionAttrStorage;
|
|
|
|
} // namespace detail
|
|
class QuadSwapDirectionAttr : public ::mlir::Attribute::AttrBase<QuadSwapDirectionAttr, ::mlir::Attribute, detail::QuadSwapDirectionAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.quad_swap_direction";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static QuadSwapDirectionAttr get(::mlir::MLIRContext *context, ::mlir::spirv::QuadSwapDirection value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"quad_swap_direction"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::QuadSwapDirection getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct OpcodeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class OpcodeAttr : public ::mlir::Attribute::AttrBase<OpcodeAttr, ::mlir::Attribute, detail::OpcodeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.opcode";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static OpcodeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::Opcode value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"opcode"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::Opcode getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct FPFastMathModeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class FPFastMathModeAttr : public ::mlir::Attribute::AttrBase<FPFastMathModeAttr, ::mlir::Attribute, detail::FPFastMathModeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.fastmath_mode";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static FPFastMathModeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::FPFastMathMode value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"fastmath_mode"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::FPFastMathMode getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct TosaExtAccTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class TosaExtAccTypeAttr : public ::mlir::Attribute::AttrBase<TosaExtAccTypeAttr, ::mlir::Attribute, detail::TosaExtAccTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.tosa_ext_acc_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static TosaExtAccTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::TosaExtAccType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"tosa_ext_acc_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::TosaExtAccType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct TosaExtResizeModeTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class TosaExtResizeModeTypeAttr : public ::mlir::Attribute::AttrBase<TosaExtResizeModeTypeAttr, ::mlir::Attribute, detail::TosaExtResizeModeTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.tosa_ext_resize_mode_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static TosaExtResizeModeTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::TosaExtResizeModeType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"tosa_ext_resize_mode_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::TosaExtResizeModeType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct TosaExtNaNPropagationModeTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class TosaExtNaNPropagationModeTypeAttr : public ::mlir::Attribute::AttrBase<TosaExtNaNPropagationModeTypeAttr, ::mlir::Attribute, detail::TosaExtNaNPropagationModeTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.tosa_ext_nan_propagation_mode_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static TosaExtNaNPropagationModeTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::TosaExtNaNPropagationModeType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"tosa_ext_nan_propagation_mode_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::TosaExtNaNPropagationModeType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct TosaExtRoundingModeTypeAttrStorage;
|
|
|
|
} // namespace detail
|
|
class TosaExtRoundingModeTypeAttr : public ::mlir::Attribute::AttrBase<TosaExtRoundingModeTypeAttr, ::mlir::Attribute, detail::TosaExtRoundingModeTypeAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.tosa_ext_rounding_mode_type";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static TosaExtRoundingModeTypeAttr get(::mlir::MLIRContext *context, ::mlir::spirv::TosaExtRoundingModeType value);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"tosa_ext_rounding_mode_type"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
::mlir::spirv::TosaExtRoundingModeType getValue() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct EntryPointABIAttrStorage;
|
|
|
|
} // namespace detail
|
|
class EntryPointABIAttr : public ::mlir::Attribute::AttrBase<EntryPointABIAttr, ::mlir::Attribute, detail::EntryPointABIAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.entry_point_abi";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static EntryPointABIAttr get(::mlir::MLIRContext *context, DenseI32ArrayAttr workgroup_size, std::optional<int> subgroup_size, std::optional<int> target_width);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"entry_point_abi"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
DenseI32ArrayAttr getWorkgroupSize() const;
|
|
std::optional<int> getSubgroupSize() const;
|
|
std::optional<int> getTargetWidth() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct LinkageAttributesAttrStorage;
|
|
|
|
} // namespace detail
|
|
class LinkageAttributesAttr : public ::mlir::Attribute::AttrBase<LinkageAttributesAttr, ::mlir::Attribute, detail::LinkageAttributesAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.linkage_attributes";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static LinkageAttributesAttr get(::mlir::MLIRContext *context, StringAttr linkage_name, mlir::spirv::LinkageTypeAttr linkage_type);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"linkage_attributes"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
StringAttr getLinkageName() const;
|
|
mlir::spirv::LinkageTypeAttr getLinkageType() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CooperativeMatrixPropertiesKHRAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CooperativeMatrixPropertiesKHRAttr : public ::mlir::Attribute::AttrBase<CooperativeMatrixPropertiesKHRAttr, ::mlir::Attribute, detail::CooperativeMatrixPropertiesKHRAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.coop_matrix_props_khr";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CooperativeMatrixPropertiesKHRAttr get(::mlir::MLIRContext *context, uint32_t m_size, uint32_t n_size, uint32_t k_size, mlir::Type a_type, mlir::Type b_type, mlir::Type c_type, mlir::Type result_type, bool acc_sat, mlir::spirv::ScopeAttr scope);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"coop_matrix_props_khr"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
uint32_t getMSize() const;
|
|
uint32_t getNSize() const;
|
|
uint32_t getKSize() const;
|
|
mlir::Type getAType() const;
|
|
mlir::Type getBType() const;
|
|
mlir::Type getCType() const;
|
|
mlir::Type getResultType() const;
|
|
bool getAccSat() const;
|
|
mlir::spirv::ScopeAttr getScope() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CacheControlLoadINTELAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CacheControlLoadINTELAttr : public ::mlir::Attribute::AttrBase<CacheControlLoadINTELAttr, ::mlir::Attribute, detail::CacheControlLoadINTELAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.cache_control_load_intel";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CacheControlLoadINTELAttr get(::mlir::MLIRContext *context, unsigned cache_level, mlir::spirv::LoadCacheControl load_cache_control);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"cache_control_load_intel"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
unsigned getCacheLevel() const;
|
|
mlir::spirv::LoadCacheControl getLoadCacheControl() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct CacheControlStoreINTELAttrStorage;
|
|
|
|
} // namespace detail
|
|
class CacheControlStoreINTELAttr : public ::mlir::Attribute::AttrBase<CacheControlStoreINTELAttr, ::mlir::Attribute, detail::CacheControlStoreINTELAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.cache_control_store_intel";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static CacheControlStoreINTELAttr get(::mlir::MLIRContext *context, unsigned cache_level, mlir::spirv::StoreCacheControl store_cache_control);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"cache_control_store_intel"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
unsigned getCacheLevel() const;
|
|
mlir::spirv::StoreCacheControl getStoreCacheControl() const;
|
|
};
|
|
namespace detail {
|
|
|
|
struct ResourceLimitsAttrStorage;
|
|
|
|
} // namespace detail
|
|
class ResourceLimitsAttr : public ::mlir::Attribute::AttrBase<ResourceLimitsAttr, ::mlir::Attribute, detail::ResourceLimitsAttrStorage> {
|
|
public:
|
|
using Base::Base;
|
|
static constexpr ::llvm::StringLiteral name = "spirv.resource_limits";
|
|
static constexpr ::llvm::StringLiteral dialectName = "spirv";
|
|
static ResourceLimitsAttr get(::mlir::MLIRContext *context, int max_compute_shared_memory_size, int max_compute_workgroup_invocations, ArrayAttr max_compute_workgroup_size, int subgroup_size, std::optional<int> min_subgroup_size, std::optional<int> max_subgroup_size, ArrayAttr cooperative_matrix_properties_khr, ArrayAttr cooperative_matrix_properties_nv);
|
|
static constexpr ::llvm::StringLiteral getMnemonic() {
|
|
return {"resource_limits"};
|
|
}
|
|
|
|
static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
|
|
void print(::mlir::AsmPrinter &odsPrinter) const;
|
|
int getMaxComputeSharedMemorySize() const;
|
|
int getMaxComputeWorkgroupInvocations() const;
|
|
ArrayAttr getMaxComputeWorkgroupSize() const;
|
|
int getSubgroupSize() const;
|
|
std::optional<int> getMinSubgroupSize() const;
|
|
std::optional<int> getMaxSubgroupSize() const;
|
|
ArrayAttr getCooperativeMatrixPropertiesKhr() const;
|
|
ArrayAttr getCooperativeMatrixPropertiesNv() const;
|
|
};
|
|
|
|
} // namespace mlir::spirv
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::VersionAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::DeviceTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::VendorAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ClientAPIAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ExtensionAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CapabilityAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::AddressingModelAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::BuiltInAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::DecorationAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::DimAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ExecutionModeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ExecutionModelAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::FPEncodingAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::FPRoundingModeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::FunctionControlAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::GroupOperationAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageFormatAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageOperandsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::LinkageTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::LoopControlAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::MemoryAccessAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::MemoryModelAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::MemorySemanticsAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ScopeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::SelectionControlAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::StorageClassAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::PackedVectorFormatAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageDepthInfoAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageArrayedInfoAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageSamplingInfoAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ImageSamplerUseInfoAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::MatrixLayoutAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CooperativeMatrixUseKHRAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CooperativeMatrixLayoutKHRAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CooperativeMatrixOperandsKHRAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::LoadCacheControlAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::StoreCacheControlAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::QuadSwapDirectionAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::OpcodeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::FPFastMathModeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::TosaExtAccTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::TosaExtResizeModeTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::TosaExtNaNPropagationModeTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::TosaExtRoundingModeTypeAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::EntryPointABIAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::LinkageAttributesAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CooperativeMatrixPropertiesKHRAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CacheControlLoadINTELAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::CacheControlStoreINTELAttr)
|
|
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::spirv::ResourceLimitsAttr)
|
|
|
|
#endif // GET_ATTRDEF_CLASSES
|
|
|