LLVMOpsAttrDefs.cpp.inc | Explore in Territory

/*===- 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::DISubrangeAttr,
::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) { … }

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) { … }

::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 { … }

} // 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 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 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
llvm/tools/mlir/include/mlir/Dialect/LLVMIR/LLVMOpsAttrDefs.cpp.inc
