llvm/tools/mlir/include/mlir/Dialect/Linalg/IR/LinalgNamedStructuredOps.yamlgen.cpp.inc

//===----------------------------------------------------------------------===//
// Implementation of CopyOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> CopyOp::getIteratorTypesArray() { … }

ArrayAttr CopyOp::getIndexingMaps() { … }

unsigned CopyOp::getNumRegionArgs() { … }

std::string CopyOp::getLibraryCallName() { … }

void CopyOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult CopyOp::parse(OpAsmParser &parser, OperationState &result) { … }
void CopyOp::print(OpAsmPrinter &p) { … }

LogicalResult CopyOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void CopyOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability CopyOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of ElemwiseUnaryOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> ElemwiseUnaryOp::getIteratorTypesArray() { … }

ArrayAttr ElemwiseUnaryOp::getIndexingMaps() { … }

unsigned ElemwiseUnaryOp::getNumRegionArgs() { … }

std::string ElemwiseUnaryOp::getLibraryCallName() { … }

void ElemwiseUnaryOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult ElemwiseUnaryOp::parse(OpAsmParser &parser, OperationState &result) { … }
void ElemwiseUnaryOp::print(OpAsmPrinter &p) { … }

LogicalResult ElemwiseUnaryOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void ElemwiseUnaryOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability ElemwiseUnaryOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of ExpOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> ExpOp::getIteratorTypesArray() { … }

ArrayAttr ExpOp::getIndexingMaps() { … }

unsigned ExpOp::getNumRegionArgs() { … }

std::string ExpOp::getLibraryCallName() { … }

void ExpOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult ExpOp::parse(OpAsmParser &parser, OperationState &result) { … }
void ExpOp::print(OpAsmPrinter &p) { … }

LogicalResult ExpOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void ExpOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability ExpOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of LogOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> LogOp::getIteratorTypesArray() { … }

ArrayAttr LogOp::getIndexingMaps() { … }

unsigned LogOp::getNumRegionArgs() { … }

std::string LogOp::getLibraryCallName() { … }

void LogOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult LogOp::parse(OpAsmParser &parser, OperationState &result) { … }
void LogOp::print(OpAsmPrinter &p) { … }

LogicalResult LogOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void LogOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability LogOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of AbsOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> AbsOp::getIteratorTypesArray() { … }

ArrayAttr AbsOp::getIndexingMaps() { … }

unsigned AbsOp::getNumRegionArgs() { … }

std::string AbsOp::getLibraryCallName() { … }

void AbsOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult AbsOp::parse(OpAsmParser &parser, OperationState &result) { … }
void AbsOp::print(OpAsmPrinter &p) { … }

LogicalResult AbsOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void AbsOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability AbsOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of CeilOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> CeilOp::getIteratorTypesArray() { … }

ArrayAttr CeilOp::getIndexingMaps() { … }

unsigned CeilOp::getNumRegionArgs() { … }

std::string CeilOp::getLibraryCallName() { … }

void CeilOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult CeilOp::parse(OpAsmParser &parser, OperationState &result) { … }
void CeilOp::print(OpAsmPrinter &p) { … }

LogicalResult CeilOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void CeilOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability CeilOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of FloorOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> FloorOp::getIteratorTypesArray() { … }

ArrayAttr FloorOp::getIndexingMaps() { … }

unsigned FloorOp::getNumRegionArgs() { … }

std::string FloorOp::getLibraryCallName() { … }

void FloorOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult FloorOp::parse(OpAsmParser &parser, OperationState &result) { … }
void FloorOp::print(OpAsmPrinter &p) { … }

LogicalResult FloorOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void FloorOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability FloorOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of NegFOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> NegFOp::getIteratorTypesArray() { … }

ArrayAttr NegFOp::getIndexingMaps() { … }

unsigned NegFOp::getNumRegionArgs() { … }

std::string NegFOp::getLibraryCallName() { … }

void NegFOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult NegFOp::parse(OpAsmParser &parser, OperationState &result) { … }
void NegFOp::print(OpAsmPrinter &p) { … }

LogicalResult NegFOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void NegFOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability NegFOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of ReciprocalOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> ReciprocalOp::getIteratorTypesArray() { … }

ArrayAttr ReciprocalOp::getIndexingMaps() { … }

unsigned ReciprocalOp::getNumRegionArgs() { … }

std::string ReciprocalOp::getLibraryCallName() { … }

void ReciprocalOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult ReciprocalOp::parse(OpAsmParser &parser, OperationState &result) { … }
void ReciprocalOp::print(OpAsmPrinter &p) { … }

LogicalResult ReciprocalOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void ReciprocalOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability ReciprocalOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of RoundOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> RoundOp::getIteratorTypesArray() { … }

ArrayAttr RoundOp::getIndexingMaps() { … }

unsigned RoundOp::getNumRegionArgs() { … }

std::string RoundOp::getLibraryCallName() { … }

void RoundOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult RoundOp::parse(OpAsmParser &parser, OperationState &result) { … }
void RoundOp::print(OpAsmPrinter &p) { … }

LogicalResult RoundOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void RoundOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability RoundOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of SqrtOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> SqrtOp::getIteratorTypesArray() { … }

ArrayAttr SqrtOp::getIndexingMaps() { … }

unsigned SqrtOp::getNumRegionArgs() { … }

std::string SqrtOp::getLibraryCallName() { … }

void SqrtOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult SqrtOp::parse(OpAsmParser &parser, OperationState &result) { … }
void SqrtOp::print(OpAsmPrinter &p) { … }

LogicalResult SqrtOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void SqrtOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability SqrtOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of RsqrtOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> RsqrtOp::getIteratorTypesArray() { … }

ArrayAttr RsqrtOp::getIndexingMaps() { … }

unsigned RsqrtOp::getNumRegionArgs() { … }

std::string RsqrtOp::getLibraryCallName() { … }

void RsqrtOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult RsqrtOp::parse(OpAsmParser &parser, OperationState &result) { … }
void RsqrtOp::print(OpAsmPrinter &p) { … }

LogicalResult RsqrtOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void RsqrtOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability RsqrtOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of SquareOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> SquareOp::getIteratorTypesArray() { … }

ArrayAttr SquareOp::getIndexingMaps() { … }

unsigned SquareOp::getNumRegionArgs() { … }

std::string SquareOp::getLibraryCallName() { … }

void SquareOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult SquareOp::parse(OpAsmParser &parser, OperationState &result) { … }
void SquareOp::print(OpAsmPrinter &p) { … }

LogicalResult SquareOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void SquareOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability SquareOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of TanhOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> TanhOp::getIteratorTypesArray() { … }

ArrayAttr TanhOp::getIndexingMaps() { … }

unsigned TanhOp::getNumRegionArgs() { … }

std::string TanhOp::getLibraryCallName() { … }

void TanhOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult TanhOp::parse(OpAsmParser &parser, OperationState &result) { … }
void TanhOp::print(OpAsmPrinter &p) { … }

LogicalResult TanhOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void TanhOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability TanhOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of ErfOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> ErfOp::getIteratorTypesArray() { … }

ArrayAttr ErfOp::getIndexingMaps() { … }

unsigned ErfOp::getNumRegionArgs() { … }

std::string ErfOp::getLibraryCallName() { … }

void ErfOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult ErfOp::parse(OpAsmParser &parser, OperationState &result) { … }
void ErfOp::print(OpAsmPrinter &p) { … }

LogicalResult ErfOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void ErfOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability ErfOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of ElemwiseBinaryOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> ElemwiseBinaryOp::getIteratorTypesArray() { … }

ArrayAttr ElemwiseBinaryOp::getIndexingMaps() { … }

unsigned ElemwiseBinaryOp::getNumRegionArgs() { … }

std::string ElemwiseBinaryOp::getLibraryCallName() { … }

void ElemwiseBinaryOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult ElemwiseBinaryOp::parse(OpAsmParser &parser, OperationState &result) { … }
void ElemwiseBinaryOp::print(OpAsmPrinter &p) { … }

LogicalResult ElemwiseBinaryOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void ElemwiseBinaryOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability ElemwiseBinaryOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of AddOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> AddOp::getIteratorTypesArray() { … }

ArrayAttr AddOp::getIndexingMaps() { … }

unsigned AddOp::getNumRegionArgs() { … }

std::string AddOp::getLibraryCallName() { … }

void AddOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult AddOp::parse(OpAsmParser &parser, OperationState &result) { … }
void AddOp::print(OpAsmPrinter &p) { … }

LogicalResult AddOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void AddOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability AddOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of SubOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> SubOp::getIteratorTypesArray() { … }

ArrayAttr SubOp::getIndexingMaps() { … }

unsigned SubOp::getNumRegionArgs() { … }

std::string SubOp::getLibraryCallName() { … }

void SubOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult SubOp::parse(OpAsmParser &parser, OperationState &result) { … }
void SubOp::print(OpAsmPrinter &p) { … }

LogicalResult SubOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void SubOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability SubOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MulOp::getIteratorTypesArray() { … }

ArrayAttr MulOp::getIndexingMaps() { … }

unsigned MulOp::getNumRegionArgs() { … }

std::string MulOp::getLibraryCallName() { … }

void MulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MulOp::print(OpAsmPrinter &p) { … }

LogicalResult MulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DivOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DivOp::getIteratorTypesArray() { … }

ArrayAttr DivOp::getIndexingMaps() { … }

unsigned DivOp::getNumRegionArgs() { … }

std::string DivOp::getLibraryCallName() { … }

void DivOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DivOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DivOp::print(OpAsmPrinter &p) { … }

LogicalResult DivOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DivOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DivOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DivUnsignedOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DivUnsignedOp::getIteratorTypesArray() { … }

ArrayAttr DivUnsignedOp::getIndexingMaps() { … }

unsigned DivUnsignedOp::getNumRegionArgs() { … }

std::string DivUnsignedOp::getLibraryCallName() { … }

void DivUnsignedOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DivUnsignedOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DivUnsignedOp::print(OpAsmPrinter &p) { … }

LogicalResult DivUnsignedOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DivUnsignedOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DivUnsignedOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MaxOp::getIteratorTypesArray() { … }

ArrayAttr MaxOp::getIndexingMaps() { … }

unsigned MaxOp::getNumRegionArgs() { … }

std::string MaxOp::getLibraryCallName() { … }

void MaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MaxOp::print(OpAsmPrinter &p) { … }

LogicalResult MaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MinOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MinOp::getIteratorTypesArray() { … }

ArrayAttr MinOp::getIndexingMaps() { … }

unsigned MinOp::getNumRegionArgs() { … }

std::string MinOp::getLibraryCallName() { … }

void MinOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MinOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MinOp::print(OpAsmPrinter &p) { … }

LogicalResult MinOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MinOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MinOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PowFOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PowFOp::getIteratorTypesArray() { … }

ArrayAttr PowFOp::getIndexingMaps() { … }

unsigned PowFOp::getNumRegionArgs() { … }

std::string PowFOp::getLibraryCallName() { … }

void PowFOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PowFOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PowFOp::print(OpAsmPrinter &p) { … }

LogicalResult PowFOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PowFOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PowFOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of SelectOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> SelectOp::getIteratorTypesArray() { … }

ArrayAttr SelectOp::getIndexingMaps() { … }

unsigned SelectOp::getNumRegionArgs() { … }

std::string SelectOp::getLibraryCallName() { … }

void SelectOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult SelectOp::parse(OpAsmParser &parser, OperationState &result) { … }
void SelectOp::print(OpAsmPrinter &p) { … }

LogicalResult SelectOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void SelectOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability SelectOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MatmulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MatmulOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(MatmulOp self) { … }

ArrayAttr MatmulOp::getIndexingMaps() { … }

unsigned MatmulOp::getNumRegionArgs() { … }

std::string MatmulOp::getLibraryCallName() { … }

void MatmulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MatmulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MatmulOp::print(OpAsmPrinter &p) { … }

LogicalResult MatmulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MatmulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MatmulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of QuantizedMatmulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> QuantizedMatmulOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(QuantizedMatmulOp self) { … }

ArrayAttr QuantizedMatmulOp::getIndexingMaps() { … }

unsigned QuantizedMatmulOp::getNumRegionArgs() { … }

std::string QuantizedMatmulOp::getLibraryCallName() { … }

void QuantizedMatmulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult QuantizedMatmulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void QuantizedMatmulOp::print(OpAsmPrinter &p) { … }

LogicalResult QuantizedMatmulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void QuantizedMatmulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability QuantizedMatmulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MatmulTransposeAOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MatmulTransposeAOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(MatmulTransposeAOp self) { … }

ArrayAttr MatmulTransposeAOp::getIndexingMaps() { … }

unsigned MatmulTransposeAOp::getNumRegionArgs() { … }

std::string MatmulTransposeAOp::getLibraryCallName() { … }

void MatmulTransposeAOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MatmulTransposeAOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MatmulTransposeAOp::print(OpAsmPrinter &p) { … }

LogicalResult MatmulTransposeAOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MatmulTransposeAOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MatmulTransposeAOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MatmulTransposeBOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MatmulTransposeBOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(MatmulTransposeBOp self) { … }

ArrayAttr MatmulTransposeBOp::getIndexingMaps() { … }

unsigned MatmulTransposeBOp::getNumRegionArgs() { … }

std::string MatmulTransposeBOp::getLibraryCallName() { … }

void MatmulTransposeBOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MatmulTransposeBOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MatmulTransposeBOp::print(OpAsmPrinter &p) { … }

LogicalResult MatmulTransposeBOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MatmulTransposeBOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MatmulTransposeBOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Mmt4DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Mmt4DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Mmt4DOp self) { … }

ArrayAttr Mmt4DOp::getIndexingMaps() { … }

unsigned Mmt4DOp::getNumRegionArgs() { … }

std::string Mmt4DOp::getLibraryCallName() { … }

void Mmt4DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Mmt4DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Mmt4DOp::print(OpAsmPrinter &p) { … }

LogicalResult Mmt4DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Mmt4DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Mmt4DOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchMmt4DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchMmt4DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchMmt4DOp self) { … }

ArrayAttr BatchMmt4DOp::getIndexingMaps() { … }

unsigned BatchMmt4DOp::getNumRegionArgs() { … }

std::string BatchMmt4DOp::getLibraryCallName() { … }

void BatchMmt4DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchMmt4DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchMmt4DOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchMmt4DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchMmt4DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchMmt4DOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchMatmulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchMatmulOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchMatmulOp self) { … }

ArrayAttr BatchMatmulOp::getIndexingMaps() { … }

unsigned BatchMatmulOp::getNumRegionArgs() { … }

std::string BatchMatmulOp::getLibraryCallName() { … }

void BatchMatmulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchMatmulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchMatmulOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchMatmulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchMatmulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchMatmulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchMatmulTransposeAOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchMatmulTransposeAOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchMatmulTransposeAOp self) { … }

ArrayAttr BatchMatmulTransposeAOp::getIndexingMaps() { … }

unsigned BatchMatmulTransposeAOp::getNumRegionArgs() { … }

std::string BatchMatmulTransposeAOp::getLibraryCallName() { … }

void BatchMatmulTransposeAOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchMatmulTransposeAOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchMatmulTransposeAOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchMatmulTransposeAOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchMatmulTransposeAOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchMatmulTransposeAOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchMatmulTransposeBOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchMatmulTransposeBOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchMatmulTransposeBOp self) { … }

ArrayAttr BatchMatmulTransposeBOp::getIndexingMaps() { … }

unsigned BatchMatmulTransposeBOp::getNumRegionArgs() { … }

std::string BatchMatmulTransposeBOp::getLibraryCallName() { … }

void BatchMatmulTransposeBOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchMatmulTransposeBOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchMatmulTransposeBOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchMatmulTransposeBOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchMatmulTransposeBOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchMatmulTransposeBOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of QuantizedBatchMatmulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> QuantizedBatchMatmulOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(QuantizedBatchMatmulOp self) { … }

ArrayAttr QuantizedBatchMatmulOp::getIndexingMaps() { … }

unsigned QuantizedBatchMatmulOp::getNumRegionArgs() { … }

std::string QuantizedBatchMatmulOp::getLibraryCallName() { … }

void QuantizedBatchMatmulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult QuantizedBatchMatmulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void QuantizedBatchMatmulOp::print(OpAsmPrinter &p) { … }

LogicalResult QuantizedBatchMatmulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void QuantizedBatchMatmulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability QuantizedBatchMatmulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchReduceMatmulOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchReduceMatmulOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchReduceMatmulOp self) { … }

ArrayAttr BatchReduceMatmulOp::getIndexingMaps() { … }

unsigned BatchReduceMatmulOp::getNumRegionArgs() { … }

std::string BatchReduceMatmulOp::getLibraryCallName() { … }

void BatchReduceMatmulOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchReduceMatmulOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchReduceMatmulOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchReduceMatmulOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchReduceMatmulOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchReduceMatmulOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of MatvecOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> MatvecOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(MatvecOp self) { … }

ArrayAttr MatvecOp::getIndexingMaps() { … }

unsigned MatvecOp::getNumRegionArgs() { … }

std::string MatvecOp::getLibraryCallName() { … }

void MatvecOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult MatvecOp::parse(OpAsmParser &parser, OperationState &result) { … }
void MatvecOp::print(OpAsmPrinter &p) { … }

LogicalResult MatvecOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void MatvecOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability MatvecOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of VecmatOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> VecmatOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(VecmatOp self) { … }

ArrayAttr VecmatOp::getIndexingMaps() { … }

unsigned VecmatOp::getNumRegionArgs() { … }

std::string VecmatOp::getLibraryCallName() { … }

void VecmatOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult VecmatOp::parse(OpAsmParser &parser, OperationState &result) { … }
void VecmatOp::print(OpAsmPrinter &p) { … }

LogicalResult VecmatOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void VecmatOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability VecmatOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchMatvecOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchMatvecOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchMatvecOp self) { … }

ArrayAttr BatchMatvecOp::getIndexingMaps() { … }

unsigned BatchMatvecOp::getNumRegionArgs() { … }

std::string BatchMatvecOp::getLibraryCallName() { … }

void BatchMatvecOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchMatvecOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchMatvecOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchMatvecOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchMatvecOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchMatvecOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of BatchVecmatOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> BatchVecmatOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(BatchVecmatOp self) { … }

ArrayAttr BatchVecmatOp::getIndexingMaps() { … }

unsigned BatchVecmatOp::getNumRegionArgs() { … }

std::string BatchVecmatOp::getLibraryCallName() { … }

void BatchVecmatOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult BatchVecmatOp::parse(OpAsmParser &parser, OperationState &result) { … }
void BatchVecmatOp::print(OpAsmPrinter &p) { … }

LogicalResult BatchVecmatOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void BatchVecmatOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability BatchVecmatOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DotOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DotOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DotOp self) { … }

ArrayAttr DotOp::getIndexingMaps() { … }

unsigned DotOp::getNumRegionArgs() { … }

std::string DotOp::getLibraryCallName() { … }

void DotOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DotOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DotOp::print(OpAsmPrinter &p) { … }

LogicalResult DotOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DotOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DotOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv1DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv1DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv1DOp self) { … }

ArrayAttr Conv1DOp::getIndexingMaps() { … }

unsigned Conv1DOp::getNumRegionArgs() { … }

std::string Conv1DOp::getLibraryCallName() { … }

void Conv1DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv1DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv1DOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv1DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv1DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv1DOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DOp self) { … }

ArrayAttr Conv2DOp::getIndexingMaps() { … }

unsigned Conv2DOp::getNumRegionArgs() { … }

std::string Conv2DOp::getLibraryCallName() { … }

void Conv2DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv3DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv3DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv3DOp self) { … }

ArrayAttr Conv3DOp::getIndexingMaps() { … }

unsigned Conv3DOp::getNumRegionArgs() { … }

std::string Conv3DOp::getLibraryCallName() { … }

void Conv3DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv3DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv3DOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv3DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv3DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv3DOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv1DNwcWcfOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv1DNwcWcfOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv1DNwcWcfOp self) { … }

ArrayAttr Conv1DNwcWcfOp::getIndexingMaps() { … }

unsigned Conv1DNwcWcfOp::getNumRegionArgs() { … }

std::string Conv1DNwcWcfOp::getLibraryCallName() { … }

bool Conv1DNwcWcfOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv1DNwcWcfOp::verifyIndexingMapRequiredAttributes() { … }

void Conv1DNwcWcfOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv1DNwcWcfOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv1DNwcWcfOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv1DNwcWcfOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv1DNwcWcfOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv1DNwcWcfOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv1DNcwFcwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv1DNcwFcwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv1DNcwFcwOp self) { … }

ArrayAttr Conv1DNcwFcwOp::getIndexingMaps() { … }

unsigned Conv1DNcwFcwOp::getNumRegionArgs() { … }

std::string Conv1DNcwFcwOp::getLibraryCallName() { … }

bool Conv1DNcwFcwOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv1DNcwFcwOp::verifyIndexingMapRequiredAttributes() { … }

void Conv1DNcwFcwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv1DNcwFcwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv1DNcwFcwOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv1DNcwFcwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv1DNcwFcwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv1DNcwFcwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNhwcHwcfOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNhwcHwcfOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNhwcHwcfOp self) { … }

ArrayAttr Conv2DNhwcHwcfOp::getIndexingMaps() { … }

unsigned Conv2DNhwcHwcfOp::getNumRegionArgs() { … }

std::string Conv2DNhwcHwcfOp::getLibraryCallName() { … }

bool Conv2DNhwcHwcfOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNhwcHwcfOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNhwcHwcfOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNhwcHwcfOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNhwcHwcfOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNhwcHwcfOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNhwcHwcfOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNhwcHwcfOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNhwcFhwcOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNhwcFhwcOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNhwcFhwcOp self) { … }

ArrayAttr Conv2DNhwcFhwcOp::getIndexingMaps() { … }

unsigned Conv2DNhwcFhwcOp::getNumRegionArgs() { … }

std::string Conv2DNhwcFhwcOp::getLibraryCallName() { … }

bool Conv2DNhwcFhwcOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNhwcFhwcOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNhwcFhwcOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNhwcFhwcOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNhwcFhwcOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNhwcFhwcOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNhwcFhwcOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNhwcFhwcOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNhwcHwcfQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNhwcHwcfQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNhwcHwcfQOp self) { … }

ArrayAttr Conv2DNhwcHwcfQOp::getIndexingMaps() { … }

unsigned Conv2DNhwcHwcfQOp::getNumRegionArgs() { … }

std::string Conv2DNhwcHwcfQOp::getLibraryCallName() { … }

bool Conv2DNhwcHwcfQOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNhwcHwcfQOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNhwcHwcfQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNhwcHwcfQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNhwcHwcfQOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNhwcHwcfQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNhwcHwcfQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNhwcHwcfQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNhwcFhwcQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNhwcFhwcQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNhwcFhwcQOp self) { … }

ArrayAttr Conv2DNhwcFhwcQOp::getIndexingMaps() { … }

unsigned Conv2DNhwcFhwcQOp::getNumRegionArgs() { … }

std::string Conv2DNhwcFhwcQOp::getLibraryCallName() { … }

bool Conv2DNhwcFhwcQOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNhwcFhwcQOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNhwcFhwcQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNhwcFhwcQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNhwcFhwcQOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNhwcFhwcQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNhwcFhwcQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNhwcFhwcQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNchwFchwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNchwFchwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNchwFchwOp self) { … }

ArrayAttr Conv2DNchwFchwOp::getIndexingMaps() { … }

unsigned Conv2DNchwFchwOp::getNumRegionArgs() { … }

std::string Conv2DNchwFchwOp::getLibraryCallName() { … }

bool Conv2DNchwFchwOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNchwFchwOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNchwFchwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNchwFchwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNchwFchwOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNchwFchwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNchwFchwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNchwFchwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNgchwFgchwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNgchwFgchwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNgchwFgchwOp self) { … }

ArrayAttr Conv2DNgchwFgchwOp::getIndexingMaps() { … }

unsigned Conv2DNgchwFgchwOp::getNumRegionArgs() { … }

std::string Conv2DNgchwFgchwOp::getLibraryCallName() { … }

bool Conv2DNgchwFgchwOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNgchwFgchwOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNgchwFgchwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNgchwFgchwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNgchwFgchwOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNgchwFgchwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNgchwFgchwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNgchwFgchwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNgchwGfchwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNgchwGfchwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNgchwGfchwOp self) { … }

ArrayAttr Conv2DNgchwGfchwOp::getIndexingMaps() { … }

unsigned Conv2DNgchwGfchwOp::getNumRegionArgs() { … }

std::string Conv2DNgchwGfchwOp::getLibraryCallName() { … }

bool Conv2DNgchwGfchwOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNgchwGfchwOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNgchwGfchwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNgchwGfchwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNgchwGfchwOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNgchwGfchwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNgchwGfchwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNgchwGfchwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv2DNgchwGfchwQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv2DNgchwGfchwQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv2DNgchwGfchwQOp self) { … }

ArrayAttr Conv2DNgchwGfchwQOp::getIndexingMaps() { … }

unsigned Conv2DNgchwGfchwQOp::getNumRegionArgs() { … }

std::string Conv2DNgchwGfchwQOp::getLibraryCallName() { … }

bool Conv2DNgchwGfchwQOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv2DNgchwGfchwQOp::verifyIndexingMapRequiredAttributes() { … }

void Conv2DNgchwGfchwQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv2DNgchwGfchwQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv2DNgchwGfchwQOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv2DNgchwGfchwQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv2DNgchwGfchwQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv2DNgchwGfchwQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv3DNdhwcDhwcfOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv3DNdhwcDhwcfOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv3DNdhwcDhwcfOp self) { … }

ArrayAttr Conv3DNdhwcDhwcfOp::getIndexingMaps() { … }

unsigned Conv3DNdhwcDhwcfOp::getNumRegionArgs() { … }

std::string Conv3DNdhwcDhwcfOp::getLibraryCallName() { … }

bool Conv3DNdhwcDhwcfOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv3DNdhwcDhwcfOp::verifyIndexingMapRequiredAttributes() { … }

void Conv3DNdhwcDhwcfOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv3DNdhwcDhwcfOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv3DNdhwcDhwcfOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv3DNdhwcDhwcfOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv3DNdhwcDhwcfOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv3DNdhwcDhwcfOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv3DNdhwcDhwcfQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv3DNdhwcDhwcfQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv3DNdhwcDhwcfQOp self) { … }

ArrayAttr Conv3DNdhwcDhwcfQOp::getIndexingMaps() { … }

unsigned Conv3DNdhwcDhwcfQOp::getNumRegionArgs() { … }

std::string Conv3DNdhwcDhwcfQOp::getLibraryCallName() { … }

bool Conv3DNdhwcDhwcfQOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv3DNdhwcDhwcfQOp::verifyIndexingMapRequiredAttributes() { … }

void Conv3DNdhwcDhwcfQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv3DNdhwcDhwcfQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv3DNdhwcDhwcfQOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv3DNdhwcDhwcfQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv3DNdhwcDhwcfQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv3DNdhwcDhwcfQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of Conv3DNcdhwFcdhwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> Conv3DNcdhwFcdhwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(Conv3DNcdhwFcdhwOp self) { … }

ArrayAttr Conv3DNcdhwFcdhwOp::getIndexingMaps() { … }

unsigned Conv3DNcdhwFcdhwOp::getNumRegionArgs() { … }

std::string Conv3DNcdhwFcdhwOp::getLibraryCallName() { … }

bool Conv3DNcdhwFcdhwOp::hasDynamicIndexingMaps() { … }
LogicalResult Conv3DNcdhwFcdhwOp::verifyIndexingMapRequiredAttributes() { … }

void Conv3DNcdhwFcdhwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult Conv3DNcdhwFcdhwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void Conv3DNcdhwFcdhwOp::print(OpAsmPrinter &p) { … }

LogicalResult Conv3DNcdhwFcdhwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void Conv3DNcdhwFcdhwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability Conv3DNcdhwFcdhwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv1DNwcWcOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv1DNwcWcOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv1DNwcWcOp self) { … }

ArrayAttr DepthwiseConv1DNwcWcOp::getIndexingMaps() { … }

unsigned DepthwiseConv1DNwcWcOp::getNumRegionArgs() { … }

std::string DepthwiseConv1DNwcWcOp::getLibraryCallName() { … }

bool DepthwiseConv1DNwcWcOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv1DNwcWcOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv1DNwcWcOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv1DNwcWcOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv1DNwcWcOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv1DNwcWcOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv1DNwcWcOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv1DNwcWcOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv1DNcwCwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv1DNcwCwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv1DNcwCwOp self) { … }

ArrayAttr DepthwiseConv1DNcwCwOp::getIndexingMaps() { … }

unsigned DepthwiseConv1DNcwCwOp::getNumRegionArgs() { … }

std::string DepthwiseConv1DNcwCwOp::getLibraryCallName() { … }

bool DepthwiseConv1DNcwCwOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv1DNcwCwOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv1DNcwCwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv1DNcwCwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv1DNcwCwOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv1DNcwCwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv1DNcwCwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv1DNcwCwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv1DNwcWcmOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv1DNwcWcmOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv1DNwcWcmOp self) { … }

ArrayAttr DepthwiseConv1DNwcWcmOp::getIndexingMaps() { … }

unsigned DepthwiseConv1DNwcWcmOp::getNumRegionArgs() { … }

std::string DepthwiseConv1DNwcWcmOp::getLibraryCallName() { … }

bool DepthwiseConv1DNwcWcmOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv1DNwcWcmOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv1DNwcWcmOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv1DNwcWcmOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv1DNwcWcmOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv1DNwcWcmOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv1DNwcWcmOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv1DNwcWcmOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv2DNhwcHwcOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv2DNhwcHwcOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv2DNhwcHwcOp self) { … }

ArrayAttr DepthwiseConv2DNhwcHwcOp::getIndexingMaps() { … }

unsigned DepthwiseConv2DNhwcHwcOp::getNumRegionArgs() { … }

std::string DepthwiseConv2DNhwcHwcOp::getLibraryCallName() { … }

bool DepthwiseConv2DNhwcHwcOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv2DNhwcHwcOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv2DNhwcHwcOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv2DNhwcHwcOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv2DNhwcHwcOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv2DNhwcHwcOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv2DNhwcHwcOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv2DNhwcHwcOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv2DNchwChwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv2DNchwChwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv2DNchwChwOp self) { … }

ArrayAttr DepthwiseConv2DNchwChwOp::getIndexingMaps() { … }

unsigned DepthwiseConv2DNchwChwOp::getNumRegionArgs() { … }

std::string DepthwiseConv2DNchwChwOp::getLibraryCallName() { … }

bool DepthwiseConv2DNchwChwOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv2DNchwChwOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv2DNchwChwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv2DNchwChwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv2DNchwChwOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv2DNchwChwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv2DNchwChwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv2DNchwChwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv2DNhwcHwcQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv2DNhwcHwcQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv2DNhwcHwcQOp self) { … }

ArrayAttr DepthwiseConv2DNhwcHwcQOp::getIndexingMaps() { … }

unsigned DepthwiseConv2DNhwcHwcQOp::getNumRegionArgs() { … }

std::string DepthwiseConv2DNhwcHwcQOp::getLibraryCallName() { … }

bool DepthwiseConv2DNhwcHwcQOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv2DNhwcHwcQOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv2DNhwcHwcQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv2DNhwcHwcQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv2DNhwcHwcQOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv2DNhwcHwcQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv2DNhwcHwcQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv2DNhwcHwcQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv2DNhwcHwcmOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv2DNhwcHwcmOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv2DNhwcHwcmOp self) { … }

ArrayAttr DepthwiseConv2DNhwcHwcmOp::getIndexingMaps() { … }

unsigned DepthwiseConv2DNhwcHwcmOp::getNumRegionArgs() { … }

std::string DepthwiseConv2DNhwcHwcmOp::getLibraryCallName() { … }

bool DepthwiseConv2DNhwcHwcmOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv2DNhwcHwcmOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv2DNhwcHwcmOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv2DNhwcHwcmOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv2DNhwcHwcmOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv2DNhwcHwcmOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv2DNhwcHwcmOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv2DNhwcHwcmOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv2DNhwcHwcmQOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv2DNhwcHwcmQOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv2DNhwcHwcmQOp self) { … }

ArrayAttr DepthwiseConv2DNhwcHwcmQOp::getIndexingMaps() { … }

unsigned DepthwiseConv2DNhwcHwcmQOp::getNumRegionArgs() { … }

std::string DepthwiseConv2DNhwcHwcmQOp::getLibraryCallName() { … }

bool DepthwiseConv2DNhwcHwcmQOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv2DNhwcHwcmQOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv2DNhwcHwcmQOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv2DNhwcHwcmQOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv2DNhwcHwcmQOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv2DNhwcHwcmQOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv2DNhwcHwcmQOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv2DNhwcHwcmQOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv3DNdhwcDhwcOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv3DNdhwcDhwcOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv3DNdhwcDhwcOp self) { … }

ArrayAttr DepthwiseConv3DNdhwcDhwcOp::getIndexingMaps() { … }

unsigned DepthwiseConv3DNdhwcDhwcOp::getNumRegionArgs() { … }

std::string DepthwiseConv3DNdhwcDhwcOp::getLibraryCallName() { … }

bool DepthwiseConv3DNdhwcDhwcOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv3DNdhwcDhwcOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv3DNdhwcDhwcOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv3DNdhwcDhwcOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv3DNdhwcDhwcOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv3DNdhwcDhwcOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv3DNdhwcDhwcOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv3DNdhwcDhwcOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv3DNcdhwCdhwOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv3DNcdhwCdhwOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv3DNcdhwCdhwOp self) { … }

ArrayAttr DepthwiseConv3DNcdhwCdhwOp::getIndexingMaps() { … }

unsigned DepthwiseConv3DNcdhwCdhwOp::getNumRegionArgs() { … }

std::string DepthwiseConv3DNcdhwCdhwOp::getLibraryCallName() { … }

bool DepthwiseConv3DNcdhwCdhwOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv3DNcdhwCdhwOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv3DNcdhwCdhwOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv3DNcdhwCdhwOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv3DNcdhwCdhwOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv3DNcdhwCdhwOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv3DNcdhwCdhwOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv3DNcdhwCdhwOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of DepthwiseConv3DNdhwcDhwcmOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> DepthwiseConv3DNdhwcDhwcmOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(DepthwiseConv3DNdhwcDhwcmOp self) { … }

ArrayAttr DepthwiseConv3DNdhwcDhwcmOp::getIndexingMaps() { … }

unsigned DepthwiseConv3DNdhwcDhwcmOp::getNumRegionArgs() { … }

std::string DepthwiseConv3DNdhwcDhwcmOp::getLibraryCallName() { … }

bool DepthwiseConv3DNdhwcDhwcmOp::hasDynamicIndexingMaps() { … }
LogicalResult DepthwiseConv3DNdhwcDhwcmOp::verifyIndexingMapRequiredAttributes() { … }

void DepthwiseConv3DNdhwcDhwcmOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult DepthwiseConv3DNdhwcDhwcmOp::parse(OpAsmParser &parser, OperationState &result) { … }
void DepthwiseConv3DNdhwcDhwcmOp::print(OpAsmPrinter &p) { … }

LogicalResult DepthwiseConv3DNdhwcDhwcmOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void DepthwiseConv3DNdhwcDhwcmOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability DepthwiseConv3DNdhwcDhwcmOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNhwcSumOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNhwcSumOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNhwcSumOp self) { … }

ArrayAttr PoolingNhwcSumOp::getIndexingMaps() { … }

unsigned PoolingNhwcSumOp::getNumRegionArgs() { … }

std::string PoolingNhwcSumOp::getLibraryCallName() { … }

bool PoolingNhwcSumOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNhwcSumOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNhwcSumOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNhwcSumOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNhwcSumOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNhwcSumOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNhwcSumOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNhwcSumOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNchwSumOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNchwSumOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNchwSumOp self) { … }

ArrayAttr PoolingNchwSumOp::getIndexingMaps() { … }

unsigned PoolingNchwSumOp::getNumRegionArgs() { … }

std::string PoolingNchwSumOp::getLibraryCallName() { … }

bool PoolingNchwSumOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNchwSumOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNchwSumOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNchwSumOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNchwSumOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNchwSumOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNchwSumOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNchwSumOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNhwcMaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNhwcMaxOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNhwcMaxOp self) { … }

ArrayAttr PoolingNhwcMaxOp::getIndexingMaps() { … }

unsigned PoolingNhwcMaxOp::getNumRegionArgs() { … }

std::string PoolingNhwcMaxOp::getLibraryCallName() { … }

bool PoolingNhwcMaxOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNhwcMaxOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNhwcMaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNhwcMaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNhwcMaxOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNhwcMaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNhwcMaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNhwcMaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNhwcMaxUnsignedOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNhwcMaxUnsignedOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNhwcMaxUnsignedOp self) { … }

ArrayAttr PoolingNhwcMaxUnsignedOp::getIndexingMaps() { … }

unsigned PoolingNhwcMaxUnsignedOp::getNumRegionArgs() { … }

std::string PoolingNhwcMaxUnsignedOp::getLibraryCallName() { … }

bool PoolingNhwcMaxUnsignedOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNhwcMaxUnsignedOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNhwcMaxUnsignedOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNhwcMaxUnsignedOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNhwcMaxUnsignedOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNhwcMaxUnsignedOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNhwcMaxUnsignedOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNhwcMaxUnsignedOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNchwMaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNchwMaxOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNchwMaxOp self) { … }

ArrayAttr PoolingNchwMaxOp::getIndexingMaps() { … }

unsigned PoolingNchwMaxOp::getNumRegionArgs() { … }

std::string PoolingNchwMaxOp::getLibraryCallName() { … }

bool PoolingNchwMaxOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNchwMaxOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNchwMaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNchwMaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNchwMaxOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNchwMaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNchwMaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNchwMaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNhwcMinOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNhwcMinOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNhwcMinOp self) { … }

ArrayAttr PoolingNhwcMinOp::getIndexingMaps() { … }

unsigned PoolingNhwcMinOp::getNumRegionArgs() { … }

std::string PoolingNhwcMinOp::getLibraryCallName() { … }

bool PoolingNhwcMinOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNhwcMinOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNhwcMinOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNhwcMinOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNhwcMinOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNhwcMinOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNhwcMinOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNhwcMinOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNhwcMinUnsignedOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNhwcMinUnsignedOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNhwcMinUnsignedOp self) { … }

ArrayAttr PoolingNhwcMinUnsignedOp::getIndexingMaps() { … }

unsigned PoolingNhwcMinUnsignedOp::getNumRegionArgs() { … }

std::string PoolingNhwcMinUnsignedOp::getLibraryCallName() { … }

bool PoolingNhwcMinUnsignedOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNhwcMinUnsignedOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNhwcMinUnsignedOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNhwcMinUnsignedOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNhwcMinUnsignedOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNhwcMinUnsignedOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNhwcMinUnsignedOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNhwcMinUnsignedOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNwcSumOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNwcSumOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNwcSumOp self) { … }

ArrayAttr PoolingNwcSumOp::getIndexingMaps() { … }

unsigned PoolingNwcSumOp::getNumRegionArgs() { … }

std::string PoolingNwcSumOp::getLibraryCallName() { … }

bool PoolingNwcSumOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNwcSumOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNwcSumOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNwcSumOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNwcSumOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNwcSumOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNwcSumOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNwcSumOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNcwSumOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNcwSumOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNcwSumOp self) { … }

ArrayAttr PoolingNcwSumOp::getIndexingMaps() { … }

unsigned PoolingNcwSumOp::getNumRegionArgs() { … }

std::string PoolingNcwSumOp::getLibraryCallName() { … }

bool PoolingNcwSumOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNcwSumOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNcwSumOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNcwSumOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNcwSumOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNcwSumOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNcwSumOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNcwSumOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNwcMaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNwcMaxOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNwcMaxOp self) { … }

ArrayAttr PoolingNwcMaxOp::getIndexingMaps() { … }

unsigned PoolingNwcMaxOp::getNumRegionArgs() { … }

std::string PoolingNwcMaxOp::getLibraryCallName() { … }

bool PoolingNwcMaxOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNwcMaxOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNwcMaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNwcMaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNwcMaxOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNwcMaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNwcMaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNwcMaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNwcMaxUnsignedOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNwcMaxUnsignedOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNwcMaxUnsignedOp self) { … }

ArrayAttr PoolingNwcMaxUnsignedOp::getIndexingMaps() { … }

unsigned PoolingNwcMaxUnsignedOp::getNumRegionArgs() { … }

std::string PoolingNwcMaxUnsignedOp::getLibraryCallName() { … }

bool PoolingNwcMaxUnsignedOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNwcMaxUnsignedOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNwcMaxUnsignedOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNwcMaxUnsignedOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNwcMaxUnsignedOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNwcMaxUnsignedOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNwcMaxUnsignedOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNwcMaxUnsignedOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNcwMaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNcwMaxOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNcwMaxOp self) { … }

ArrayAttr PoolingNcwMaxOp::getIndexingMaps() { … }

unsigned PoolingNcwMaxOp::getNumRegionArgs() { … }

std::string PoolingNcwMaxOp::getLibraryCallName() { … }

bool PoolingNcwMaxOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNcwMaxOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNcwMaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNcwMaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNcwMaxOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNcwMaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNcwMaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNcwMaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNwcMinOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNwcMinOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNwcMinOp self) { … }

ArrayAttr PoolingNwcMinOp::getIndexingMaps() { … }

unsigned PoolingNwcMinOp::getNumRegionArgs() { … }

std::string PoolingNwcMinOp::getLibraryCallName() { … }

bool PoolingNwcMinOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNwcMinOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNwcMinOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNwcMinOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNwcMinOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNwcMinOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNwcMinOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNwcMinOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNwcMinUnsignedOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNwcMinUnsignedOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNwcMinUnsignedOp self) { … }

ArrayAttr PoolingNwcMinUnsignedOp::getIndexingMaps() { … }

unsigned PoolingNwcMinUnsignedOp::getNumRegionArgs() { … }

std::string PoolingNwcMinUnsignedOp::getLibraryCallName() { … }

bool PoolingNwcMinUnsignedOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNwcMinUnsignedOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNwcMinUnsignedOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNwcMinUnsignedOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNwcMinUnsignedOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNwcMinUnsignedOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNwcMinUnsignedOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNwcMinUnsignedOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNdhwcSumOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNdhwcSumOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNdhwcSumOp self) { … }

ArrayAttr PoolingNdhwcSumOp::getIndexingMaps() { … }

unsigned PoolingNdhwcSumOp::getNumRegionArgs() { … }

std::string PoolingNdhwcSumOp::getLibraryCallName() { … }

bool PoolingNdhwcSumOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNdhwcSumOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNdhwcSumOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNdhwcSumOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNdhwcSumOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNdhwcSumOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNdhwcSumOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNdhwcSumOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNdhwcMaxOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNdhwcMaxOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNdhwcMaxOp self) { … }

ArrayAttr PoolingNdhwcMaxOp::getIndexingMaps() { … }

unsigned PoolingNdhwcMaxOp::getNumRegionArgs() { … }

std::string PoolingNdhwcMaxOp::getLibraryCallName() { … }

bool PoolingNdhwcMaxOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNdhwcMaxOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNdhwcMaxOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNdhwcMaxOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNdhwcMaxOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNdhwcMaxOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNdhwcMaxOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNdhwcMaxOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of PoolingNdhwcMinOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> PoolingNdhwcMinOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(PoolingNdhwcMinOp self) { … }

ArrayAttr PoolingNdhwcMinOp::getIndexingMaps() { … }

unsigned PoolingNdhwcMinOp::getNumRegionArgs() { … }

std::string PoolingNdhwcMinOp::getLibraryCallName() { … }

bool PoolingNdhwcMinOp::hasDynamicIndexingMaps() { … }
LogicalResult PoolingNdhwcMinOp::verifyIndexingMapRequiredAttributes() { … }

void PoolingNdhwcMinOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult PoolingNdhwcMinOp::parse(OpAsmParser &parser, OperationState &result) { … }
void PoolingNdhwcMinOp::print(OpAsmPrinter &p) { … }

LogicalResult PoolingNdhwcMinOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void PoolingNdhwcMinOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability PoolingNdhwcMinOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of FillOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> FillOp::getIteratorTypesArray() { … }

ArrayAttr FillOp::getIndexingMaps() { … }

unsigned FillOp::getNumRegionArgs() { … }

std::string FillOp::getLibraryCallName() { … }

void FillOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult FillOp::parse(OpAsmParser &parser, OperationState &result) { … }
void FillOp::print(OpAsmPrinter &p) { … }

LogicalResult FillOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void FillOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability FillOp::getSpeculatability() { … }

//===----------------------------------------------------------------------===//
// Implementation of FillRng2DOp
//===----------------------------------------------------------------------===//

SmallVector<utils::IteratorType> FillRng2DOp::getIteratorTypesArray() { … }

static SmallVector<AffineExpr> getSymbolBindings(FillRng2DOp self) { … }

ArrayAttr FillRng2DOp::getIndexingMaps() { … }

unsigned FillRng2DOp::getNumRegionArgs() { … }

std::string FillRng2DOp::getLibraryCallName() { … }

void FillRng2DOp::regionBuilder(ImplicitLocOpBuilder &b,
                        Block &block, ArrayRef<NamedAttribute> attrs) { … }

ParseResult FillRng2DOp::parse(OpAsmParser &parser, OperationState &result) { … }
void FillRng2DOp::print(OpAsmPrinter &p) { … }

LogicalResult FillRng2DOp::fold(FoldAdaptor,
                        SmallVectorImpl<OpFoldResult> &) { … }
void FillRng2DOp::getEffects(SmallVectorImpl<
    SideEffects::EffectInstance<MemoryEffects::Effect> >&effects) { … }
Speculation::Speculatability FillRng2DOp::getSpeculatability() { … }