/*===- 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