llvm/tools/mlir/include/mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* AttrDef Definitions                                                        *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_ATTRDEF_LIST
#undef GET_ATTRDEF_LIST

::mlir::LLVM::CConvAttr,
::mlir::LLVM::ComdatAttr,
::mlir::LLVM::LinkageAttr,
::mlir::LLVM::FramePointerKindAttr,
::mlir::LLVM::LoopVectorizeAttr,
::mlir::LLVM::LoopInterleaveAttr,
::mlir::LLVM::LoopUnrollAttr,
::mlir::LLVM::LoopUnrollAndJamAttr,
::mlir::LLVM::LoopLICMAttr,
::mlir::LLVM::LoopDistributeAttr,
::mlir::LLVM::LoopPipelineAttr,
::mlir::LLVM::LoopPeeledAttr,
::mlir::LLVM::LoopUnswitchAttr,
::mlir::LLVM::LoopAnnotationAttr,
::mlir::LLVM::DIExpressionElemAttr,
::mlir::LLVM::DIExpressionAttr,
::mlir::LLVM::DINullTypeAttr,
::mlir::LLVM::DIBasicTypeAttr,
::mlir::LLVM::DICompileUnitAttr,
::mlir::LLVM::DICompositeTypeAttr,
::mlir::LLVM::DIDerivedTypeAttr,
::mlir::LLVM::DIFileAttr,
::mlir::LLVM::DIGlobalVariableExpressionAttr,
::mlir::LLVM::DIGlobalVariableAttr,
::mlir::LLVM::DILexicalBlockAttr,
::mlir::LLVM::DILexicalBlockFileAttr,
::mlir::LLVM::DILocalVariableAttr,
::mlir::LLVM::DISubprogramAttr,
::mlir::LLVM::DIModuleAttr,
::mlir::LLVM::DINamespaceAttr,
::mlir::LLVM::DIImportedEntityAttr,
::mlir::LLVM::DIAnnotationAttr,
::mlir::LLVM::DISubrangeAttr,
::mlir::LLVM::DICommonBlockAttr,
::mlir::LLVM::DISubroutineTypeAttr,
::mlir::LLVM::DILabelAttr,
::mlir::LLVM::DIStringTypeAttr,
::mlir::LLVM::MemoryEffectsAttr,
::mlir::LLVM::AliasScopeDomainAttr,
::mlir::LLVM::AliasScopeAttr,
::mlir::LLVM::AccessGroupAttr,
::mlir::LLVM::TBAARootAttr,
::mlir::LLVM::TBAAMemberAttr,
::mlir::LLVM::TBAATypeDescriptorAttr,
::mlir::LLVM::TBAATagAttr,
::mlir::LLVM::ConstantRangeAttr,
::mlir::LLVM::VScaleRangeAttr,
::mlir::LLVM::TargetFeaturesAttr,
::mlir::LLVM::UndefAttr,
::mlir::LLVM::PoisonAttr,
::mlir::LLVM::VecTypeHintAttr,
::mlir::LLVM::ZeroAttr,
::mlir::LLVM::TailCallKindAttr,
::mlir::LLVM::WorkgroupAttributionAttr,
::mlir::LLVM::IntegerOverflowFlagsAttr,
::mlir::LLVM::FastmathFlagsAttr

#endif  // GET_ATTRDEF_LIST

#ifdef GET_ATTRDEF_CLASSES
#undef GET_ATTRDEF_CLASSES

static ::mlir::OptionalParseResult generatedAttributeParser(::mlir::AsmParser &parser, ::llvm::StringRef *mnemonic, ::mlir::Type type, ::mlir::Attribute &value) {}

static ::llvm::LogicalResult generatedAttributePrinter(::mlir::Attribute def, ::mlir::AsmPrinter &printer) {}

namespace mlir {
namespace LLVM {
namespace detail {
struct CConvAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
CConvAttr CConvAttr::get(::mlir::MLIRContext *context, CConv CallingConv) {}

::mlir::Attribute CConvAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void CConvAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

CConv CConvAttr::getCallingConv() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::CConvAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct ComdatAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
ComdatAttr ComdatAttr::get(::mlir::MLIRContext *context, comdat::Comdat comdat) {}

::mlir::Attribute ComdatAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void ComdatAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

comdat::Comdat ComdatAttr::getComdat() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::ComdatAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LinkageAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LinkageAttr LinkageAttr::get(::mlir::MLIRContext *context, linkage::Linkage linkage) {}

::mlir::Attribute LinkageAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LinkageAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

linkage::Linkage LinkageAttr::getLinkage() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LinkageAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct FramePointerKindAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
FramePointerKindAttr FramePointerKindAttr::get(::mlir::MLIRContext *context, framePointerKind::FramePointerKind framePointerKind) {}

::mlir::Attribute FramePointerKindAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void FramePointerKindAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

framePointerKind::FramePointerKind FramePointerKindAttr::getFramePointerKind() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::FramePointerKindAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopVectorizeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopVectorizeAttr LoopVectorizeAttr::get(::mlir::MLIRContext *context, BoolAttr disable, BoolAttr predicateEnable, BoolAttr scalableEnable, IntegerAttr width, LoopAnnotationAttr followupVectorized, LoopAnnotationAttr followupEpilogue, LoopAnnotationAttr followupAll) {}

::mlir::Attribute LoopVectorizeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopVectorizeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopVectorizeAttr::getDisable() const {}

BoolAttr LoopVectorizeAttr::getPredicateEnable() const {}

BoolAttr LoopVectorizeAttr::getScalableEnable() const {}

IntegerAttr LoopVectorizeAttr::getWidth() const {}

LoopAnnotationAttr LoopVectorizeAttr::getFollowupVectorized() const {}

LoopAnnotationAttr LoopVectorizeAttr::getFollowupEpilogue() const {}

LoopAnnotationAttr LoopVectorizeAttr::getFollowupAll() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopVectorizeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopInterleaveAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopInterleaveAttr LoopInterleaveAttr::get(::mlir::MLIRContext *context, IntegerAttr count) {}

::mlir::Attribute LoopInterleaveAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopInterleaveAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

IntegerAttr LoopInterleaveAttr::getCount() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopInterleaveAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopUnrollAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopUnrollAttr LoopUnrollAttr::get(::mlir::MLIRContext *context, BoolAttr disable, IntegerAttr count, BoolAttr runtimeDisable, BoolAttr full, LoopAnnotationAttr followupUnrolled, LoopAnnotationAttr followupRemainder, LoopAnnotationAttr followupAll) {}

::mlir::Attribute LoopUnrollAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopUnrollAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopUnrollAttr::getDisable() const {}

IntegerAttr LoopUnrollAttr::getCount() const {}

BoolAttr LoopUnrollAttr::getRuntimeDisable() const {}

BoolAttr LoopUnrollAttr::getFull() const {}

LoopAnnotationAttr LoopUnrollAttr::getFollowupUnrolled() const {}

LoopAnnotationAttr LoopUnrollAttr::getFollowupRemainder() const {}

LoopAnnotationAttr LoopUnrollAttr::getFollowupAll() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopUnrollAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopUnrollAndJamAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopUnrollAndJamAttr LoopUnrollAndJamAttr::get(::mlir::MLIRContext *context, BoolAttr disable, IntegerAttr count, LoopAnnotationAttr followupOuter, LoopAnnotationAttr followupInner, LoopAnnotationAttr followupRemainderOuter, LoopAnnotationAttr followupRemainderInner, LoopAnnotationAttr followupAll) {}

::mlir::Attribute LoopUnrollAndJamAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopUnrollAndJamAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopUnrollAndJamAttr::getDisable() const {}

IntegerAttr LoopUnrollAndJamAttr::getCount() const {}

LoopAnnotationAttr LoopUnrollAndJamAttr::getFollowupOuter() const {}

LoopAnnotationAttr LoopUnrollAndJamAttr::getFollowupInner() const {}

LoopAnnotationAttr LoopUnrollAndJamAttr::getFollowupRemainderOuter() const {}

LoopAnnotationAttr LoopUnrollAndJamAttr::getFollowupRemainderInner() const {}

LoopAnnotationAttr LoopUnrollAndJamAttr::getFollowupAll() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopUnrollAndJamAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopLICMAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopLICMAttr LoopLICMAttr::get(::mlir::MLIRContext *context, BoolAttr disable, BoolAttr versioningDisable) {}

::mlir::Attribute LoopLICMAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopLICMAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopLICMAttr::getDisable() const {}

BoolAttr LoopLICMAttr::getVersioningDisable() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopLICMAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopDistributeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopDistributeAttr LoopDistributeAttr::get(::mlir::MLIRContext *context, BoolAttr disable, LoopAnnotationAttr followupCoincident, LoopAnnotationAttr followupSequential, LoopAnnotationAttr followupFallback, LoopAnnotationAttr followupAll) {}

::mlir::Attribute LoopDistributeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopDistributeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopDistributeAttr::getDisable() const {}

LoopAnnotationAttr LoopDistributeAttr::getFollowupCoincident() const {}

LoopAnnotationAttr LoopDistributeAttr::getFollowupSequential() const {}

LoopAnnotationAttr LoopDistributeAttr::getFollowupFallback() const {}

LoopAnnotationAttr LoopDistributeAttr::getFollowupAll() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopDistributeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopPipelineAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopPipelineAttr LoopPipelineAttr::get(::mlir::MLIRContext *context, BoolAttr disable, IntegerAttr initiationinterval) {}

::mlir::Attribute LoopPipelineAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopPipelineAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopPipelineAttr::getDisable() const {}

IntegerAttr LoopPipelineAttr::getInitiationinterval() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopPipelineAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopPeeledAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopPeeledAttr LoopPeeledAttr::get(::mlir::MLIRContext *context, IntegerAttr count) {}

::mlir::Attribute LoopPeeledAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopPeeledAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

IntegerAttr LoopPeeledAttr::getCount() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopPeeledAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopUnswitchAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopUnswitchAttr LoopUnswitchAttr::get(::mlir::MLIRContext *context, BoolAttr partialDisable) {}

::mlir::Attribute LoopUnswitchAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopUnswitchAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopUnswitchAttr::getPartialDisable() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopUnswitchAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct LoopAnnotationAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
LoopAnnotationAttr LoopAnnotationAttr::get(::mlir::MLIRContext *context, BoolAttr disableNonforced, LoopVectorizeAttr vectorize, LoopInterleaveAttr interleave, LoopUnrollAttr unroll, LoopUnrollAndJamAttr unrollAndJam, LoopLICMAttr licm, LoopDistributeAttr distribute, LoopPipelineAttr pipeline, LoopPeeledAttr peeled, LoopUnswitchAttr unswitch, BoolAttr mustProgress, BoolAttr isVectorized, FusedLoc startLoc, FusedLoc endLoc, ::llvm::ArrayRef<AccessGroupAttr> parallelAccesses) {}

::mlir::Attribute LoopAnnotationAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void LoopAnnotationAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

BoolAttr LoopAnnotationAttr::getDisableNonforced() const {}

LoopVectorizeAttr LoopAnnotationAttr::getVectorize() const {}

LoopInterleaveAttr LoopAnnotationAttr::getInterleave() const {}

LoopUnrollAttr LoopAnnotationAttr::getUnroll() const {}

LoopUnrollAndJamAttr LoopAnnotationAttr::getUnrollAndJam() const {}

LoopLICMAttr LoopAnnotationAttr::getLicm() const {}

LoopDistributeAttr LoopAnnotationAttr::getDistribute() const {}

LoopPipelineAttr LoopAnnotationAttr::getPipeline() const {}

LoopPeeledAttr LoopAnnotationAttr::getPeeled() const {}

LoopUnswitchAttr LoopAnnotationAttr::getUnswitch() const {}

BoolAttr LoopAnnotationAttr::getMustProgress() const {}

BoolAttr LoopAnnotationAttr::getIsVectorized() const {}

FusedLoc LoopAnnotationAttr::getStartLoc() const {}

FusedLoc LoopAnnotationAttr::getEndLoc() const {}

::llvm::ArrayRef<AccessGroupAttr> LoopAnnotationAttr::getParallelAccesses() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::LoopAnnotationAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIExpressionElemAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIExpressionElemAttr DIExpressionElemAttr::get(::mlir::MLIRContext *context, unsigned opcode, ::llvm::ArrayRef<uint64_t> arguments) {}

::mlir::Attribute DIExpressionElemAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIExpressionElemAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DIExpressionElemAttr::getOpcode() const {}

::llvm::ArrayRef<uint64_t> DIExpressionElemAttr::getArguments() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIExpressionElemAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIExpressionAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIExpressionAttr DIExpressionAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<DIExpressionElemAttr> operations) {}

::mlir::Attribute DIExpressionAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIExpressionAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::llvm::ArrayRef<DIExpressionElemAttr> DIExpressionAttr::getOperations() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIExpressionAttr)
namespace mlir {
namespace LLVM {
} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DINullTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIBasicTypeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIBasicTypeAttr DIBasicTypeAttr::get(::mlir::MLIRContext *context, unsigned tag, StringAttr name, uint64_t sizeInBits, unsigned encoding) {}

DIBasicTypeAttr DIBasicTypeAttr::get(::mlir::MLIRContext *context, unsigned tag, const Twine &name, uint64_t sizeInBits, unsigned encoding) {}

::mlir::Attribute DIBasicTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIBasicTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DIBasicTypeAttr::getTag() const {}

StringAttr DIBasicTypeAttr::getName() const {}

uint64_t DIBasicTypeAttr::getSizeInBits() const {}

unsigned DIBasicTypeAttr::getEncoding() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIBasicTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DICompileUnitAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DICompileUnitAttr DICompileUnitAttr::get(::mlir::MLIRContext *context, DistinctAttr id, unsigned sourceLanguage, DIFileAttr file, StringAttr producer, bool isOptimized, DIEmissionKind emissionKind, DINameTableKind nameTableKind) {}

DICompileUnitAttr DICompileUnitAttr::get(DistinctAttr id, unsigned sourceLanguage, DIFileAttr file, StringAttr producer, bool isOptimized, DIEmissionKind emissionKind, DINameTableKind nameTableKind) {}

::mlir::Attribute DICompileUnitAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DICompileUnitAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr DICompileUnitAttr::getId() const {}

unsigned DICompileUnitAttr::getSourceLanguage() const {}

DIFileAttr DICompileUnitAttr::getFile() const {}

StringAttr DICompileUnitAttr::getProducer() const {}

bool DICompileUnitAttr::getIsOptimized() const {}

DIEmissionKind DICompileUnitAttr::getEmissionKind() const {}

DINameTableKind DICompileUnitAttr::getNameTableKind() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DICompileUnitAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DICompositeTypeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DICompositeTypeAttr DICompositeTypeAttr::get(::mlir::MLIRContext *context, DistinctAttr recId, bool isRecSelf, unsigned tag, StringAttr name, DIFileAttr file, uint32_t line, DIScopeAttr scope, DITypeAttr baseType, DIFlags flags, uint64_t sizeInBits, uint64_t alignInBits, ::llvm::ArrayRef<DINodeAttr> elements, DIExpressionAttr dataLocation, DIExpressionAttr rank, DIExpressionAttr allocated, DIExpressionAttr associated) {}

DICompositeTypeAttr DICompositeTypeAttr::get(::mlir::MLIRContext *context, unsigned tag, StringAttr name, DIFileAttr file, uint32_t line, DIScopeAttr scope, DITypeAttr baseType, DIFlags flags, uint64_t sizeInBits, uint64_t alignInBits, ArrayRef<DINodeAttr> elements, DIExpressionAttr dataLocation, DIExpressionAttr rank, DIExpressionAttr allocated, DIExpressionAttr associated) {}

::mlir::Attribute DICompositeTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DICompositeTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr DICompositeTypeAttr::getRecId() const {}

bool DICompositeTypeAttr::getIsRecSelf() const {}

unsigned DICompositeTypeAttr::getTag() const {}

StringAttr DICompositeTypeAttr::getName() const {}

DIFileAttr DICompositeTypeAttr::getFile() const {}

uint32_t DICompositeTypeAttr::getLine() const {}

DIScopeAttr DICompositeTypeAttr::getScope() const {}

DITypeAttr DICompositeTypeAttr::getBaseType() const {}

DIFlags DICompositeTypeAttr::getFlags() const {}

uint64_t DICompositeTypeAttr::getSizeInBits() const {}

uint64_t DICompositeTypeAttr::getAlignInBits() const {}

::llvm::ArrayRef<DINodeAttr> DICompositeTypeAttr::getElements() const {}

DIExpressionAttr DICompositeTypeAttr::getDataLocation() const {}

DIExpressionAttr DICompositeTypeAttr::getRank() const {}

DIExpressionAttr DICompositeTypeAttr::getAllocated() const {}

DIExpressionAttr DICompositeTypeAttr::getAssociated() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DICompositeTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIDerivedTypeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIDerivedTypeAttr DIDerivedTypeAttr::get(::mlir::MLIRContext *context, unsigned tag, StringAttr name, DITypeAttr baseType, uint64_t sizeInBits, uint32_t alignInBits, uint64_t offsetInBits, std::optional<unsigned> dwarfAddressSpace, DINodeAttr extraData) {}

::mlir::Attribute DIDerivedTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIDerivedTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DIDerivedTypeAttr::getTag() const {}

StringAttr DIDerivedTypeAttr::getName() const {}

DITypeAttr DIDerivedTypeAttr::getBaseType() const {}

uint64_t DIDerivedTypeAttr::getSizeInBits() const {}

uint32_t DIDerivedTypeAttr::getAlignInBits() const {}

uint64_t DIDerivedTypeAttr::getOffsetInBits() const {}

std::optional<unsigned> DIDerivedTypeAttr::getDwarfAddressSpace() const {}

DINodeAttr DIDerivedTypeAttr::getExtraData() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIDerivedTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIFileAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIFileAttr DIFileAttr::get(::mlir::MLIRContext *context, StringAttr name, StringAttr directory) {}

DIFileAttr DIFileAttr::get(::mlir::MLIRContext *context, StringRef name, StringRef directory) {}

::mlir::Attribute DIFileAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIFileAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

StringAttr DIFileAttr::getName() const {}

StringAttr DIFileAttr::getDirectory() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIFileAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIGlobalVariableExpressionAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIGlobalVariableExpressionAttr DIGlobalVariableExpressionAttr::get(::mlir::MLIRContext *context, DIGlobalVariableAttr var, DIExpressionAttr expr) {}

::mlir::Attribute DIGlobalVariableExpressionAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIGlobalVariableExpressionAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIGlobalVariableAttr DIGlobalVariableExpressionAttr::getVar() const {}

DIExpressionAttr DIGlobalVariableExpressionAttr::getExpr() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIGlobalVariableExpressionAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIGlobalVariableAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIGlobalVariableAttr DIGlobalVariableAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, StringAttr name, StringAttr linkageName, DIFileAttr file, unsigned line, DITypeAttr type, bool isLocalToUnit, bool isDefined, unsigned alignInBits) {}

::mlir::Attribute DIGlobalVariableAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIGlobalVariableAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DIGlobalVariableAttr::getScope() const {}

StringAttr DIGlobalVariableAttr::getName() const {}

StringAttr DIGlobalVariableAttr::getLinkageName() const {}

DIFileAttr DIGlobalVariableAttr::getFile() const {}

unsigned DIGlobalVariableAttr::getLine() const {}

DITypeAttr DIGlobalVariableAttr::getType() const {}

bool DIGlobalVariableAttr::getIsLocalToUnit() const {}

bool DIGlobalVariableAttr::getIsDefined() const {}

unsigned DIGlobalVariableAttr::getAlignInBits() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIGlobalVariableAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DILexicalBlockAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DILexicalBlockAttr DILexicalBlockAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, DIFileAttr file, unsigned line, unsigned column) {}

DILexicalBlockAttr DILexicalBlockAttr::get(DIScopeAttr scope, DIFileAttr file, unsigned line, unsigned column) {}

::mlir::Attribute DILexicalBlockAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DILexicalBlockAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DILexicalBlockAttr::getScope() const {}

DIFileAttr DILexicalBlockAttr::getFile() const {}

unsigned DILexicalBlockAttr::getLine() const {}

unsigned DILexicalBlockAttr::getColumn() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DILexicalBlockAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DILexicalBlockFileAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DILexicalBlockFileAttr DILexicalBlockFileAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, DIFileAttr file, unsigned discriminator) {}

DILexicalBlockFileAttr DILexicalBlockFileAttr::get(DIScopeAttr scope, DIFileAttr file, unsigned discriminator) {}

::mlir::Attribute DILexicalBlockFileAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DILexicalBlockFileAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DILexicalBlockFileAttr::getScope() const {}

DIFileAttr DILexicalBlockFileAttr::getFile() const {}

unsigned DILexicalBlockFileAttr::getDiscriminator() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DILexicalBlockFileAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DILocalVariableAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DILocalVariableAttr DILocalVariableAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, StringAttr name, DIFileAttr file, unsigned line, unsigned arg, unsigned alignInBits, DITypeAttr type, DIFlags flags) {}

DILocalVariableAttr DILocalVariableAttr::get(DIScopeAttr scope, StringRef name, DIFileAttr file, unsigned line, unsigned arg, unsigned alignInBits, DITypeAttr type, DIFlags flags) {}

::mlir::Attribute DILocalVariableAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DILocalVariableAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DILocalVariableAttr::getScope() const {}

StringAttr DILocalVariableAttr::getName() const {}

DIFileAttr DILocalVariableAttr::getFile() const {}

unsigned DILocalVariableAttr::getLine() const {}

unsigned DILocalVariableAttr::getArg() const {}

unsigned DILocalVariableAttr::getAlignInBits() const {}

DITypeAttr DILocalVariableAttr::getType() const {}

DIFlags DILocalVariableAttr::getFlags() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DILocalVariableAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DISubprogramAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DISubprogramAttr DISubprogramAttr::get(::mlir::MLIRContext *context, DistinctAttr recId, bool isRecSelf, DistinctAttr id, DICompileUnitAttr compileUnit, DIScopeAttr scope, StringAttr name, StringAttr linkageName, DIFileAttr file, unsigned line, unsigned scopeLine, DISubprogramFlags subprogramFlags, DISubroutineTypeAttr type, ::llvm::ArrayRef<DINodeAttr> retainedNodes, ::llvm::ArrayRef<DINodeAttr> annotations) {}

DISubprogramAttr DISubprogramAttr::get(::mlir::MLIRContext *context, DistinctAttr id, DICompileUnitAttr compileUnit, DIScopeAttr scope, StringAttr name, StringAttr linkageName, DIFileAttr file, unsigned line, unsigned scopeLine, DISubprogramFlags subprogramFlags, DISubroutineTypeAttr type, ArrayRef<DINodeAttr> retainedNodes, ArrayRef<DINodeAttr> annotations) {}

::mlir::Attribute DISubprogramAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DISubprogramAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr DISubprogramAttr::getRecId() const {}

bool DISubprogramAttr::getIsRecSelf() const {}

DistinctAttr DISubprogramAttr::getId() const {}

DICompileUnitAttr DISubprogramAttr::getCompileUnit() const {}

DIScopeAttr DISubprogramAttr::getScope() const {}

StringAttr DISubprogramAttr::getName() const {}

StringAttr DISubprogramAttr::getLinkageName() const {}

DIFileAttr DISubprogramAttr::getFile() const {}

unsigned DISubprogramAttr::getLine() const {}

unsigned DISubprogramAttr::getScopeLine() const {}

DISubprogramFlags DISubprogramAttr::getSubprogramFlags() const {}

DISubroutineTypeAttr DISubprogramAttr::getType() const {}

::llvm::ArrayRef<DINodeAttr> DISubprogramAttr::getRetainedNodes() const {}

::llvm::ArrayRef<DINodeAttr> DISubprogramAttr::getAnnotations() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DISubprogramAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIModuleAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIModuleAttr DIModuleAttr::get(::mlir::MLIRContext *context, DIFileAttr file, DIScopeAttr scope, StringAttr name, StringAttr configMacros, StringAttr includePath, StringAttr apinotes, unsigned line, bool isDecl) {}

::mlir::Attribute DIModuleAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIModuleAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIFileAttr DIModuleAttr::getFile() const {}

DIScopeAttr DIModuleAttr::getScope() const {}

StringAttr DIModuleAttr::getName() const {}

StringAttr DIModuleAttr::getConfigMacros() const {}

StringAttr DIModuleAttr::getIncludePath() const {}

StringAttr DIModuleAttr::getApinotes() const {}

unsigned DIModuleAttr::getLine() const {}

bool DIModuleAttr::getIsDecl() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIModuleAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DINamespaceAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DINamespaceAttr DINamespaceAttr::get(::mlir::MLIRContext *context, StringAttr name, DIScopeAttr scope, bool exportSymbols) {}

::mlir::Attribute DINamespaceAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DINamespaceAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

StringAttr DINamespaceAttr::getName() const {}

DIScopeAttr DINamespaceAttr::getScope() const {}

bool DINamespaceAttr::getExportSymbols() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DINamespaceAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIImportedEntityAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIImportedEntityAttr DIImportedEntityAttr::get(::mlir::MLIRContext *context, unsigned tag, DIScopeAttr scope, DINodeAttr entity, DIFileAttr file, unsigned line, StringAttr name, ::llvm::ArrayRef<DINodeAttr> elements) {}

::mlir::Attribute DIImportedEntityAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIImportedEntityAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DIImportedEntityAttr::getTag() const {}

DIScopeAttr DIImportedEntityAttr::getScope() const {}

DINodeAttr DIImportedEntityAttr::getEntity() const {}

DIFileAttr DIImportedEntityAttr::getFile() const {}

unsigned DIImportedEntityAttr::getLine() const {}

StringAttr DIImportedEntityAttr::getName() const {}

::llvm::ArrayRef<DINodeAttr> DIImportedEntityAttr::getElements() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIImportedEntityAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIAnnotationAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIAnnotationAttr DIAnnotationAttr::get(::mlir::MLIRContext *context, StringAttr name, StringAttr value) {}

::mlir::Attribute DIAnnotationAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIAnnotationAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

StringAttr DIAnnotationAttr::getName() const {}

StringAttr DIAnnotationAttr::getValue() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIAnnotationAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DISubrangeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DISubrangeAttr DISubrangeAttr::get(::mlir::MLIRContext *context, ::mlir::Attribute count, ::mlir::Attribute lowerBound, ::mlir::Attribute upperBound, ::mlir::Attribute stride) {}

::mlir::Attribute DISubrangeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DISubrangeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::mlir::Attribute DISubrangeAttr::getCount() const {}

::mlir::Attribute DISubrangeAttr::getLowerBound() const {}

::mlir::Attribute DISubrangeAttr::getUpperBound() const {}

::mlir::Attribute DISubrangeAttr::getStride() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DISubrangeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DICommonBlockAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DICommonBlockAttr DICommonBlockAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, DIGlobalVariableAttr decl, StringAttr name, DIFileAttr file, unsigned line) {}

::mlir::Attribute DICommonBlockAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DICommonBlockAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DICommonBlockAttr::getScope() const {}

DIGlobalVariableAttr DICommonBlockAttr::getDecl() const {}

StringAttr DICommonBlockAttr::getName() const {}

DIFileAttr DICommonBlockAttr::getFile() const {}

unsigned DICommonBlockAttr::getLine() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DICommonBlockAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DISubroutineTypeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DISubroutineTypeAttr DISubroutineTypeAttr::get(::mlir::MLIRContext *context, unsigned callingConvention, ::llvm::ArrayRef<DITypeAttr> types) {}

DISubroutineTypeAttr DISubroutineTypeAttr::get(::mlir::MLIRContext *context, ArrayRef<DITypeAttr> types) {}

::mlir::Attribute DISubroutineTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DISubroutineTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DISubroutineTypeAttr::getCallingConvention() const {}

::llvm::ArrayRef<DITypeAttr> DISubroutineTypeAttr::getTypes() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DISubroutineTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DILabelAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DILabelAttr DILabelAttr::get(::mlir::MLIRContext *context, DIScopeAttr scope, StringAttr name, DIFileAttr file, unsigned line) {}

DILabelAttr DILabelAttr::get(DIScopeAttr scope, StringRef name, DIFileAttr file, unsigned line) {}

::mlir::Attribute DILabelAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DILabelAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DIScopeAttr DILabelAttr::getScope() const {}

StringAttr DILabelAttr::getName() const {}

DIFileAttr DILabelAttr::getFile() const {}

unsigned DILabelAttr::getLine() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DILabelAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct DIStringTypeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
DIStringTypeAttr DIStringTypeAttr::get(::mlir::MLIRContext *context, unsigned tag, StringAttr name, uint64_t sizeInBits, uint32_t alignInBits, DIVariableAttr stringLength, DIExpressionAttr stringLengthExp, DIExpressionAttr stringLocationExp, unsigned encoding) {}

::mlir::Attribute DIStringTypeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void DIStringTypeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

unsigned DIStringTypeAttr::getTag() const {}

StringAttr DIStringTypeAttr::getName() const {}

uint64_t DIStringTypeAttr::getSizeInBits() const {}

uint32_t DIStringTypeAttr::getAlignInBits() const {}

DIVariableAttr DIStringTypeAttr::getStringLength() const {}

DIExpressionAttr DIStringTypeAttr::getStringLengthExp() const {}

DIExpressionAttr DIStringTypeAttr::getStringLocationExp() const {}

unsigned DIStringTypeAttr::getEncoding() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::DIStringTypeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct MemoryEffectsAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
MemoryEffectsAttr MemoryEffectsAttr::get(::mlir::MLIRContext *context, ModRefInfo other, ModRefInfo argMem, ModRefInfo inaccessibleMem) {}

::mlir::Attribute MemoryEffectsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void MemoryEffectsAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

ModRefInfo MemoryEffectsAttr::getOther() const {}

ModRefInfo MemoryEffectsAttr::getArgMem() const {}

ModRefInfo MemoryEffectsAttr::getInaccessibleMem() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::MemoryEffectsAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct AliasScopeDomainAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
AliasScopeDomainAttr AliasScopeDomainAttr::get(::mlir::MLIRContext *context, DistinctAttr id, StringAttr description) {}

AliasScopeDomainAttr AliasScopeDomainAttr::get(::mlir::MLIRContext *context, StringAttr description) {}

::mlir::Attribute AliasScopeDomainAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void AliasScopeDomainAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr AliasScopeDomainAttr::getId() const {}

StringAttr AliasScopeDomainAttr::getDescription() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::AliasScopeDomainAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct AliasScopeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
AliasScopeAttr AliasScopeAttr::get(::mlir::MLIRContext *context, DistinctAttr id, AliasScopeDomainAttr domain, StringAttr description) {}

AliasScopeAttr AliasScopeAttr::get(AliasScopeDomainAttr domain, StringAttr description) {}

::mlir::Attribute AliasScopeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void AliasScopeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr AliasScopeAttr::getId() const {}

AliasScopeDomainAttr AliasScopeAttr::getDomain() const {}

StringAttr AliasScopeAttr::getDescription() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::AliasScopeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct AccessGroupAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
AccessGroupAttr AccessGroupAttr::get(::mlir::MLIRContext *context, DistinctAttr id) {}

AccessGroupAttr AccessGroupAttr::get(::mlir::MLIRContext *context) {}

::mlir::Attribute AccessGroupAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void AccessGroupAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

DistinctAttr AccessGroupAttr::getId() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::AccessGroupAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TBAARootAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TBAARootAttr TBAARootAttr::get(::mlir::MLIRContext *context, StringAttr id) {}

::mlir::Attribute TBAARootAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TBAARootAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

StringAttr TBAARootAttr::getId() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TBAARootAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TBAAMemberAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TBAAMemberAttr TBAAMemberAttr::get(::mlir::MLIRContext *context, TBAANodeAttr typeDesc, int64_t offset) {}

TBAAMemberAttr TBAAMemberAttr::get(TBAANodeAttr typeDesc, int64_t offset) {}

::mlir::Attribute TBAAMemberAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TBAAMemberAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

TBAANodeAttr TBAAMemberAttr::getTypeDesc() const {}

int64_t TBAAMemberAttr::getOffset() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TBAAMemberAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TBAATypeDescriptorAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TBAATypeDescriptorAttr TBAATypeDescriptorAttr::get(::mlir::MLIRContext *context, ::llvm::StringRef id, ::llvm::ArrayRef<TBAAMemberAttr> members) {}

::mlir::Attribute TBAATypeDescriptorAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TBAATypeDescriptorAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::llvm::StringRef TBAATypeDescriptorAttr::getId() const {}

::llvm::ArrayRef<TBAAMemberAttr> TBAATypeDescriptorAttr::getMembers() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TBAATypeDescriptorAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TBAATagAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TBAATagAttr TBAATagAttr::get(::mlir::MLIRContext *context, TBAATypeDescriptorAttr base_type, TBAATypeDescriptorAttr access_type, int64_t offset, bool constant) {}

TBAATagAttr TBAATagAttr::get(TBAATypeDescriptorAttr baseType, TBAATypeDescriptorAttr accessType, int64_t offset) {}

::mlir::Attribute TBAATagAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TBAATagAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

TBAATypeDescriptorAttr TBAATagAttr::getBaseType() const {}

TBAATypeDescriptorAttr TBAATagAttr::getAccessType() const {}

int64_t TBAATagAttr::getOffset() const {}

bool TBAATagAttr::getConstant() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TBAATagAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct ConstantRangeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
ConstantRangeAttr ConstantRangeAttr::get(::mlir::MLIRContext *context, ::llvm::APInt lower, ::llvm::APInt upper) {}

ConstantRangeAttr ConstantRangeAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::APInt lower, ::llvm::APInt upper) {}

ConstantRangeAttr ConstantRangeAttr::get(::mlir::MLIRContext *context, uint32_t bitWidth, int64_t lower, int64_t upper) {}

ConstantRangeAttr ConstantRangeAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, uint32_t bitWidth, int64_t lower, int64_t upper) {}

::llvm::LogicalResult ConstantRangeAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::APInt lower, ::llvm::APInt upper) {}

::llvm::APInt ConstantRangeAttr::getLower() const {}

::llvm::APInt ConstantRangeAttr::getUpper() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::ConstantRangeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct VScaleRangeAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
VScaleRangeAttr VScaleRangeAttr::get(::mlir::MLIRContext *context, IntegerAttr minRange, IntegerAttr maxRange) {}

::mlir::Attribute VScaleRangeAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void VScaleRangeAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

IntegerAttr VScaleRangeAttr::getMinRange() const {}

IntegerAttr VScaleRangeAttr::getMaxRange() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::VScaleRangeAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TargetFeaturesAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TargetFeaturesAttr TargetFeaturesAttr::get(::mlir::MLIRContext *context, ::llvm::ArrayRef<StringAttr> features) {}

TargetFeaturesAttr TargetFeaturesAttr::getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, ::llvm::ArrayRef<StringAttr> features) {}

::llvm::LogicalResult TargetFeaturesAttr::verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::llvm::ArrayRef<StringAttr> features) {}

::mlir::Attribute TargetFeaturesAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TargetFeaturesAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::llvm::ArrayRef<StringAttr> TargetFeaturesAttr::getFeatures() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TargetFeaturesAttr)
namespace mlir {
namespace LLVM {
} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::UndefAttr)
namespace mlir {
namespace LLVM {
} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::PoisonAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct VecTypeHintAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
VecTypeHintAttr VecTypeHintAttr::get(::mlir::MLIRContext *context, TypeAttr hint, bool is_signed) {}

::mlir::Attribute VecTypeHintAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void VecTypeHintAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

TypeAttr VecTypeHintAttr::getHint() const {}

bool VecTypeHintAttr::getIsSigned() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::VecTypeHintAttr)
namespace mlir {
namespace LLVM {
} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::ZeroAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct TailCallKindAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
TailCallKindAttr TailCallKindAttr::get(::mlir::MLIRContext *context, TailCallKind tailCallKind) {}

::mlir::Attribute TailCallKindAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void TailCallKindAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

TailCallKind TailCallKindAttr::getTailCallKind() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::TailCallKindAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct WorkgroupAttributionAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
WorkgroupAttributionAttr WorkgroupAttributionAttr::get(::mlir::MLIRContext *context, IntegerAttr num_elements, TypeAttr element_type) {}

::mlir::Attribute WorkgroupAttributionAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void WorkgroupAttributionAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

IntegerAttr WorkgroupAttributionAttr::getNumElements() const {}

TypeAttr WorkgroupAttributionAttr::getElementType() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::WorkgroupAttributionAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct IntegerOverflowFlagsAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
IntegerOverflowFlagsAttr IntegerOverflowFlagsAttr::get(::mlir::MLIRContext *context, ::mlir::LLVM::IntegerOverflowFlags value) {}

::mlir::Attribute IntegerOverflowFlagsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void IntegerOverflowFlagsAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::mlir::LLVM::IntegerOverflowFlags IntegerOverflowFlagsAttr::getValue() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::IntegerOverflowFlagsAttr)
namespace mlir {
namespace LLVM {
namespace detail {
struct FastmathFlagsAttrStorage : public ::mlir::AttributeStorage {};
} // namespace detail
FastmathFlagsAttr FastmathFlagsAttr::get(::mlir::MLIRContext *context, ::mlir::LLVM::FastmathFlags value) {}

::mlir::Attribute FastmathFlagsAttr::parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType) {}

void FastmathFlagsAttr::print(::mlir::AsmPrinter &odsPrinter) const {}

::mlir::LLVM::FastmathFlags FastmathFlagsAttr::getValue() const {}

} // namespace LLVM
} // namespace mlir
MLIR_DEFINE_EXPLICIT_TYPE_ID(::mlir::LLVM::FastmathFlagsAttr)
namespace mlir {
namespace LLVM {

/// Parse an attribute registered to this dialect.
::mlir::Attribute LLVMDialect::parseAttribute(::mlir::DialectAsmParser &parser,
                                      ::mlir::Type type) const {}
/// Print an attribute registered to this dialect.
void LLVMDialect::printAttribute(::mlir::Attribute attr,
                         ::mlir::DialectAsmPrinter &printer) const {}
} // namespace LLVM
} // namespace mlir

#endif  // GET_ATTRDEF_CLASSES