[Mlir-commits] [mlir] c0342a2 - [mlir] Switching accessors to prefixed form (NFC)
Jacques Pienaar
llvmlistbot at llvm.org
Mon Dec 20 08:04:52 PST 2021
Author: Jacques Pienaar
Date: 2021-12-20T08:03:43-08:00
New Revision: c0342a2de8aa9ffe129bce50e9c90647a772bb2b
URL: https://github.com/llvm/llvm-project/commit/c0342a2de8aa9ffe129bce50e9c90647a772bb2b
DIFF: https://github.com/llvm/llvm-project/commit/c0342a2de8aa9ffe129bce50e9c90647a772bb2b.diff
LOG: [mlir] Switching accessors to prefixed form (NFC)
Makes eventual prefixing flag flip smaller change.
Added:
Modified:
mlir/include/mlir/Dialect/SCF/SCFOps.td
mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp
mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp
mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp
mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp
mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp
mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp
mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp
mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp
mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp
mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp
mlir/lib/Dialect/SCF/SCF.cpp
mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp
mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp
mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
mlir/lib/Dialect/SCF/Transforms/Utils.cpp
mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
mlir/lib/Target/Cpp/TranslateToCpp.cpp
mlir/lib/Transforms/LoopCoalescing.cpp
mlir/lib/Transforms/Utils/LoopUtils.cpp
Removed:
################################################################################
diff --git a/mlir/include/mlir/Dialect/SCF/SCFOps.td b/mlir/include/mlir/Dialect/SCF/SCFOps.td
index 508d2aaa54642..01386ce4a5c25 100644
--- a/mlir/include/mlir/Dialect/SCF/SCFOps.td
+++ b/mlir/include/mlir/Dialect/SCF/SCFOps.td
@@ -392,13 +392,13 @@ def IfOp : SCF_Op<"if",
let extraClassDeclaration = [{
OpBuilder getThenBodyBuilder(OpBuilder::Listener *listener = nullptr) {
Block* body = getBody(0);
- return results().empty() ? OpBuilder::atBlockTerminator(body, listener)
- : OpBuilder::atBlockEnd(body, listener);
+ return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
+ : OpBuilder::atBlockEnd(body, listener);
}
OpBuilder getElseBodyBuilder(OpBuilder::Listener *listener = nullptr) {
Block* body = getBody(1);
- return results().empty() ? OpBuilder::atBlockTerminator(body, listener)
- : OpBuilder::atBlockEnd(body, listener);
+ return getResults().empty() ? OpBuilder::atBlockTerminator(body, listener)
+ : OpBuilder::atBlockEnd(body, listener);
}
Block* thenBlock();
YieldOp thenYield();
@@ -489,8 +489,8 @@ def ParallelOp : SCF_Op<"parallel",
ValueRange getInductionVars() {
return getBody()->getArguments();
}
- unsigned getNumLoops() { return step().size(); }
- unsigned getNumReductions() { return initVals().size(); }
+ unsigned getNumLoops() { return getStep().size(); }
+ unsigned getNumReductions() { return getInitVals().size(); }
}];
let hasCanonicalizer = 1;
diff --git a/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp b/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp
index 0467dd9c2bfe2..8b48549b38052 100644
--- a/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp
+++ b/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp
@@ -365,9 +365,9 @@ class AffineForLowering : public OpRewritePattern<AffineForOp> {
auto scfForOp = rewriter.create<scf::ForOp>(loc, lowerBound, upperBound,
step, op.getIterOperands());
rewriter.eraseBlock(scfForOp.getBody());
- rewriter.inlineRegionBefore(op.region(), scfForOp.region(),
- scfForOp.region().end());
- rewriter.replaceOp(op, scfForOp.results());
+ rewriter.inlineRegionBefore(op.region(), scfForOp.getRegion(),
+ scfForOp.getRegion().end());
+ rewriter.replaceOp(op, scfForOp.getResults());
return success();
}
};
@@ -416,9 +416,9 @@ class AffineParallelLowering : public OpRewritePattern<AffineParallelOp> {
upperBoundTuple, steps,
/*bodyBuilderFn=*/nullptr);
rewriter.eraseBlock(parOp.getBody());
- rewriter.inlineRegionBefore(op.region(), parOp.region(),
- parOp.region().end());
- rewriter.replaceOp(op, parOp.results());
+ rewriter.inlineRegionBefore(op.region(), parOp.getRegion(),
+ parOp.getRegion().end());
+ rewriter.replaceOp(op, parOp.getResults());
return success();
}
// Case with affine.parallel with reduction operations/return values.
@@ -444,8 +444,8 @@ class AffineParallelLowering : public OpRewritePattern<AffineParallelOp> {
// Copy the body of the affine.parallel op.
rewriter.eraseBlock(parOp.getBody());
- rewriter.inlineRegionBefore(op.region(), parOp.region(),
- parOp.region().end());
+ rewriter.inlineRegionBefore(op.region(), parOp.getRegion(),
+ parOp.getRegion().end());
assert(reductions.size() == affineParOpTerminator->getNumOperands() &&
"Unequal number of reductions and operands.");
for (unsigned i = 0, end = reductions.size(); i < end; i++) {
@@ -458,14 +458,14 @@ class AffineParallelLowering : public OpRewritePattern<AffineParallelOp> {
rewriter.setInsertionPoint(&parOp.getBody()->back());
auto reduceOp = rewriter.create<scf::ReduceOp>(
loc, affineParOpTerminator->getOperand(i));
- rewriter.setInsertionPointToEnd(&reduceOp.reductionOperator().front());
- Value reductionResult =
- getReductionOp(reductionOpValue, rewriter, loc,
- reduceOp.reductionOperator().front().getArgument(0),
- reduceOp.reductionOperator().front().getArgument(1));
+ rewriter.setInsertionPointToEnd(&reduceOp.getReductionOperator().front());
+ Value reductionResult = getReductionOp(
+ reductionOpValue, rewriter, loc,
+ reduceOp.getReductionOperator().front().getArgument(0),
+ reduceOp.getReductionOperator().front().getArgument(1));
rewriter.create<scf::ReduceReturnOp>(loc, reductionResult);
}
- rewriter.replaceOp(op, parOp.results());
+ rewriter.replaceOp(op, parOp.getResults());
return success();
}
};
@@ -512,15 +512,16 @@ class AffineIfLowering : public OpRewritePattern<AffineIfOp> {
bool hasElseRegion = !op.elseRegion().empty();
auto ifOp = rewriter.create<scf::IfOp>(loc, op.getResultTypes(), cond,
hasElseRegion);
- rewriter.inlineRegionBefore(op.thenRegion(), &ifOp.thenRegion().back());
- rewriter.eraseBlock(&ifOp.thenRegion().back());
+ rewriter.inlineRegionBefore(op.thenRegion(), &ifOp.getThenRegion().back());
+ rewriter.eraseBlock(&ifOp.getThenRegion().back());
if (hasElseRegion) {
- rewriter.inlineRegionBefore(op.elseRegion(), &ifOp.elseRegion().back());
- rewriter.eraseBlock(&ifOp.elseRegion().back());
+ rewriter.inlineRegionBefore(op.elseRegion(),
+ &ifOp.getElseRegion().back());
+ rewriter.eraseBlock(&ifOp.getElseRegion().back());
}
// Replace the Affine IfOp finally.
- rewriter.replaceOp(op, ifOp.results());
+ rewriter.replaceOp(op, ifOp.getResults());
return success();
}
};
diff --git a/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp b/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp
index 3753c4ca44904..592d1839f8f83 100644
--- a/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp
+++ b/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp
@@ -64,7 +64,7 @@ struct AbsOpConversion : public ConvertOpToLLVMPattern<complex::AbsOp> {
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
- ComplexStructBuilder complexStruct(adaptor.complex());
+ ComplexStructBuilder complexStruct(adaptor.getComplex());
Value real = complexStruct.real(rewriter, op.getLoc());
Value imag = complexStruct.imaginary(rewriter, op.getLoc());
@@ -88,8 +88,8 @@ struct CreateOpConversion : public ConvertOpToLLVMPattern<complex::CreateOp> {
auto loc = complexOp.getLoc();
auto structType = typeConverter->convertType(complexOp.getType());
auto complexStruct = ComplexStructBuilder::undef(rewriter, loc, structType);
- complexStruct.setReal(rewriter, loc, adaptor.real());
- complexStruct.setImaginary(rewriter, loc, adaptor.imaginary());
+ complexStruct.setReal(rewriter, loc, adaptor.getReal());
+ complexStruct.setImaginary(rewriter, loc, adaptor.getImaginary());
rewriter.replaceOp(complexOp, {complexStruct});
return success();
@@ -103,7 +103,7 @@ struct ReOpConversion : public ConvertOpToLLVMPattern<complex::ReOp> {
matchAndRewrite(complex::ReOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
// Extract real part from the complex number struct.
- ComplexStructBuilder complexStruct(adaptor.complex());
+ ComplexStructBuilder complexStruct(adaptor.getComplex());
Value real = complexStruct.real(rewriter, op.getLoc());
rewriter.replaceOp(op, real);
@@ -118,7 +118,7 @@ struct ImOpConversion : public ConvertOpToLLVMPattern<complex::ImOp> {
matchAndRewrite(complex::ImOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
// Extract imaginary part from the complex number struct.
- ComplexStructBuilder complexStruct(adaptor.complex());
+ ComplexStructBuilder complexStruct(adaptor.getComplex());
Value imaginary = complexStruct.imaginary(rewriter, op.getLoc());
rewriter.replaceOp(op, imaginary);
@@ -139,10 +139,10 @@ unpackBinaryComplexOperands(OpTy op, typename OpTy::Adaptor adaptor,
// Extract real and imaginary values from operands.
BinaryComplexOperands unpacked;
- ComplexStructBuilder lhs(adaptor.lhs());
+ ComplexStructBuilder lhs(adaptor.getLhs());
unpacked.lhs.real(lhs.real(rewriter, loc));
unpacked.lhs.imag(lhs.imaginary(rewriter, loc));
- ComplexStructBuilder rhs(adaptor.rhs());
+ ComplexStructBuilder rhs(adaptor.getRhs());
unpacked.rhs.real(rhs.real(rewriter, loc));
unpacked.rhs.imag(rhs.imaginary(rewriter, loc));
diff --git a/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp b/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp
index 8bbc6afc0354a..2766c12663506 100644
--- a/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp
+++ b/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp
@@ -32,8 +32,10 @@ struct AbsOpConversion : public OpConversionPattern<complex::AbsOp> {
auto loc = op.getLoc();
auto type = op.getType();
- Value real = rewriter.create<complex::ReOp>(loc, type, adaptor.complex());
- Value imag = rewriter.create<complex::ImOp>(loc, type, adaptor.complex());
+ Value real =
+ rewriter.create<complex::ReOp>(loc, type, adaptor.getComplex());
+ Value imag =
+ rewriter.create<complex::ImOp>(loc, type, adaptor.getComplex());
Value realSqr = rewriter.create<arith::MulFOp>(loc, real, real);
Value imagSqr = rewriter.create<arith::MulFOp>(loc, imag, imag);
Value sqNorm = rewriter.create<arith::AddFOp>(loc, realSqr, imagSqr);
@@ -54,13 +56,15 @@ struct ComparisonOpConversion : public OpConversionPattern<ComparisonOp> {
matchAndRewrite(ComparisonOp op, typename ComparisonOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
- auto type =
- adaptor.lhs().getType().template cast<ComplexType>().getElementType();
-
- Value realLhs = rewriter.create<complex::ReOp>(loc, type, adaptor.lhs());
- Value imagLhs = rewriter.create<complex::ImOp>(loc, type, adaptor.lhs());
- Value realRhs = rewriter.create<complex::ReOp>(loc, type, adaptor.rhs());
- Value imagRhs = rewriter.create<complex::ImOp>(loc, type, adaptor.rhs());
+ auto type = adaptor.getLhs()
+ .getType()
+ .template cast<ComplexType>()
+ .getElementType();
+
+ Value realLhs = rewriter.create<complex::ReOp>(loc, type, adaptor.getLhs());
+ Value imagLhs = rewriter.create<complex::ImOp>(loc, type, adaptor.getLhs());
+ Value realRhs = rewriter.create<complex::ReOp>(loc, type, adaptor.getRhs());
+ Value imagRhs = rewriter.create<complex::ImOp>(loc, type, adaptor.getRhs());
Value realComparison =
rewriter.create<arith::CmpFOp>(loc, p, realLhs, realRhs);
Value imagComparison =
@@ -82,16 +86,16 @@ struct BinaryComplexOpConversion : public OpConversionPattern<BinaryComplexOp> {
LogicalResult
matchAndRewrite(BinaryComplexOp op, typename BinaryComplexOp::Adaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- auto type = adaptor.lhs().getType().template cast<ComplexType>();
+ auto type = adaptor.getLhs().getType().template cast<ComplexType>();
auto elementType = type.getElementType().template cast<FloatType>();
mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
- Value realLhs = b.create<complex::ReOp>(elementType, adaptor.lhs());
- Value realRhs = b.create<complex::ReOp>(elementType, adaptor.rhs());
+ Value realLhs = b.create<complex::ReOp>(elementType, adaptor.getLhs());
+ Value realRhs = b.create<complex::ReOp>(elementType, adaptor.getRhs());
Value resultReal =
b.create<BinaryStandardOp>(elementType, realLhs, realRhs);
- Value imagLhs = b.create<complex::ImOp>(elementType, adaptor.lhs());
- Value imagRhs = b.create<complex::ImOp>(elementType, adaptor.rhs());
+ Value imagLhs = b.create<complex::ImOp>(elementType, adaptor.getLhs());
+ Value imagRhs = b.create<complex::ImOp>(elementType, adaptor.getRhs());
Value resultImag =
b.create<BinaryStandardOp>(elementType, imagLhs, imagRhs);
rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
@@ -107,17 +111,17 @@ struct DivOpConversion : public OpConversionPattern<complex::DivOp> {
matchAndRewrite(complex::DivOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
- auto type = adaptor.lhs().getType().cast<ComplexType>();
+ auto type = adaptor.getLhs().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
Value lhsReal =
- rewriter.create<complex::ReOp>(loc, elementType, adaptor.lhs());
+ rewriter.create<complex::ReOp>(loc, elementType, adaptor.getLhs());
Value lhsImag =
- rewriter.create<complex::ImOp>(loc, elementType, adaptor.lhs());
+ rewriter.create<complex::ImOp>(loc, elementType, adaptor.getLhs());
Value rhsReal =
- rewriter.create<complex::ReOp>(loc, elementType, adaptor.rhs());
+ rewriter.create<complex::ReOp>(loc, elementType, adaptor.getRhs());
Value rhsImag =
- rewriter.create<complex::ImOp>(loc, elementType, adaptor.rhs());
+ rewriter.create<complex::ImOp>(loc, elementType, adaptor.getRhs());
// Smith's algorithm to divide complex numbers. It is just a bit smarter
// way to compute the following formula:
@@ -326,13 +330,13 @@ struct ExpOpConversion : public OpConversionPattern<complex::ExpOp> {
matchAndRewrite(complex::ExpOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
- auto type = adaptor.complex().getType().cast<ComplexType>();
+ auto type = adaptor.getComplex().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
Value real =
- rewriter.create<complex::ReOp>(loc, elementType, adaptor.complex());
+ rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());
Value imag =
- rewriter.create<complex::ImOp>(loc, elementType, adaptor.complex());
+ rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());
Value expReal = rewriter.create<math::ExpOp>(loc, real);
Value cosImag = rewriter.create<math::CosOp>(loc, imag);
Value resultReal = rewriter.create<arith::MulFOp>(loc, expReal, cosImag);
@@ -351,14 +355,14 @@ struct LogOpConversion : public OpConversionPattern<complex::LogOp> {
LogicalResult
matchAndRewrite(complex::LogOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- auto type = adaptor.complex().getType().cast<ComplexType>();
+ auto type = adaptor.getComplex().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
- Value abs = b.create<complex::AbsOp>(elementType, adaptor.complex());
+ Value abs = b.create<complex::AbsOp>(elementType, adaptor.getComplex());
Value resultReal = b.create<math::LogOp>(elementType, abs);
- Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
- Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
+ Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());
+ Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());
Value resultImag = b.create<math::Atan2Op>(elementType, imag, real);
rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, resultReal,
resultImag);
@@ -372,12 +376,12 @@ struct Log1pOpConversion : public OpConversionPattern<complex::Log1pOp> {
LogicalResult
matchAndRewrite(complex::Log1pOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- auto type = adaptor.complex().getType().cast<ComplexType>();
+ auto type = adaptor.getComplex().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
- Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
- Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
+ Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());
+ Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());
Value one = b.create<arith::ConstantOp>(elementType,
b.getFloatAttr(elementType, 1));
Value realPlusOne = b.create<arith::AddFOp>(real, one);
@@ -394,16 +398,16 @@ struct MulOpConversion : public OpConversionPattern<complex::MulOp> {
matchAndRewrite(complex::MulOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
- auto type = adaptor.lhs().getType().cast<ComplexType>();
+ auto type = adaptor.getLhs().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
- Value lhsReal = b.create<complex::ReOp>(elementType, adaptor.lhs());
+ Value lhsReal = b.create<complex::ReOp>(elementType, adaptor.getLhs());
Value lhsRealAbs = b.create<math::AbsOp>(lhsReal);
- Value lhsImag = b.create<complex::ImOp>(elementType, adaptor.lhs());
+ Value lhsImag = b.create<complex::ImOp>(elementType, adaptor.getLhs());
Value lhsImagAbs = b.create<math::AbsOp>(lhsImag);
- Value rhsReal = b.create<complex::ReOp>(elementType, adaptor.rhs());
+ Value rhsReal = b.create<complex::ReOp>(elementType, adaptor.getRhs());
Value rhsRealAbs = b.create<math::AbsOp>(rhsReal);
- Value rhsImag = b.create<complex::ImOp>(elementType, adaptor.rhs());
+ Value rhsImag = b.create<complex::ImOp>(elementType, adaptor.getRhs());
Value rhsImagAbs = b.create<math::AbsOp>(rhsImag);
Value lhsRealTimesRhsReal = b.create<arith::MulFOp>(lhsReal, rhsReal);
@@ -567,13 +571,13 @@ struct NegOpConversion : public OpConversionPattern<complex::NegOp> {
matchAndRewrite(complex::NegOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
auto loc = op.getLoc();
- auto type = adaptor.complex().getType().cast<ComplexType>();
+ auto type = adaptor.getComplex().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
Value real =
- rewriter.create<complex::ReOp>(loc, elementType, adaptor.complex());
+ rewriter.create<complex::ReOp>(loc, elementType, adaptor.getComplex());
Value imag =
- rewriter.create<complex::ImOp>(loc, elementType, adaptor.complex());
+ rewriter.create<complex::ImOp>(loc, elementType, adaptor.getComplex());
Value negReal = rewriter.create<arith::NegFOp>(loc, real);
Value negImag = rewriter.create<arith::NegFOp>(loc, imag);
rewriter.replaceOpWithNewOp<complex::CreateOp>(op, type, negReal, negImag);
@@ -587,12 +591,12 @@ struct SignOpConversion : public OpConversionPattern<complex::SignOp> {
LogicalResult
matchAndRewrite(complex::SignOp op, OpAdaptor adaptor,
ConversionPatternRewriter &rewriter) const override {
- auto type = adaptor.complex().getType().cast<ComplexType>();
+ auto type = adaptor.getComplex().getType().cast<ComplexType>();
auto elementType = type.getElementType().cast<FloatType>();
mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter);
- Value real = b.create<complex::ReOp>(elementType, adaptor.complex());
- Value imag = b.create<complex::ImOp>(elementType, adaptor.complex());
+ Value real = b.create<complex::ReOp>(elementType, adaptor.getComplex());
+ Value imag = b.create<complex::ImOp>(elementType, adaptor.getComplex());
Value zero =
b.create<arith::ConstantOp>(elementType, b.getZeroAttr(elementType));
Value realIsZero =
@@ -600,11 +604,12 @@ struct SignOpConversion : public OpConversionPattern<complex::SignOp> {
Value imagIsZero =
b.create<arith::CmpFOp>(arith::CmpFPredicate::OEQ, imag, zero);
Value isZero = b.create<arith::AndIOp>(realIsZero, imagIsZero);
- auto abs = b.create<complex::AbsOp>(elementType, adaptor.complex());
+ auto abs = b.create<complex::AbsOp>(elementType, adaptor.getComplex());
Value realSign = b.create<arith::DivFOp>(real, abs);
Value imagSign = b.create<arith::DivFOp>(imag, abs);
Value sign = b.create<complex::CreateOp>(type, realSign, imagSign);
- rewriter.replaceOpWithNewOp<SelectOp>(op, isZero, adaptor.complex(), sign);
+ rewriter.replaceOpWithNewOp<SelectOp>(op, isZero, adaptor.getComplex(),
+ sign);
return success();
}
};
diff --git a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
index 2e46ca18782dc..7243c2516a3de 100644
--- a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
+++ b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp
@@ -425,9 +425,9 @@ static LogicalResult processParallelLoop(
return {};
};
- for (auto config : llvm::zip(mapping, parallelOp.getInductionVars(),
- parallelOp.lowerBound(), parallelOp.upperBound(),
- parallelOp.step())) {
+ for (auto config : llvm::zip(
+ mapping, parallelOp.getInductionVars(), parallelOp.getLowerBound(),
+ parallelOp.getUpperBound(), parallelOp.getStep())) {
Attribute mappingAttribute;
Value iv, lowerBound, upperBound, step;
std::tie(mappingAttribute, iv, lowerBound, upperBound, step) = config;
@@ -518,7 +518,7 @@ static LogicalResult processParallelLoop(
loc, arith::CmpIPredicate::slt, newIndex,
cloningMap.lookupOrDefault(originalBound));
scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, pred, false);
- rewriter.setInsertionPointToStart(&ifOp.thenRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
// Put a sentinel into the worklist so we know when to pop out of the
// if body again. We use the launchOp here, as that cannot be part of
// the bodies instruction.
diff --git a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
index 657f04111f02d..16fbb3ec6807e 100644
--- a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
+++ b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
@@ -119,7 +119,7 @@ matchSelectReduction(Block &block, ArrayRef<Predicate> lessThanPredicates,
if (!sameOperands && !swappedOperands)
return false;
- if (select.getResult() != terminator.result())
+ if (select.getResult() != terminator.getResult())
return false;
// The reduction is a min if it uses less-than predicates with same operands
@@ -182,10 +182,10 @@ static omp::ReductionDeclareOp createDecl(PatternRewriter &builder,
Attribute initValue) {
OpBuilder::InsertionGuard guard(builder);
auto decl = builder.create<omp::ReductionDeclareOp>(
- reduce.getLoc(), "__scf_reduction", reduce.operand().getType());
+ reduce.getLoc(), "__scf_reduction", reduce.getOperand().getType());
symbolTable.insert(decl);
- Type type = reduce.operand().getType();
+ Type type = reduce.getOperand().getType();
builder.createBlock(&decl.initializerRegion(), decl.initializerRegion().end(),
{type});
builder.setInsertionPointToEnd(&decl.initializerRegion().back());
@@ -211,7 +211,7 @@ static omp::ReductionDeclareOp addAtomicRMW(OpBuilder &builder,
omp::ReductionDeclareOp decl,
scf::ReduceOp reduce) {
OpBuilder::InsertionGuard guard(builder);
- Type type = reduce.operand().getType();
+ Type type = reduce.getOperand().getType();
Type ptrType = LLVM::LLVMPointerType::get(type);
builder.createBlock(&decl.atomicReductionRegion(),
decl.atomicReductionRegion().end(), {ptrType, ptrType});
@@ -247,7 +247,7 @@ static omp::ReductionDeclareOp declareReduction(PatternRewriter &builder,
"expected reduction region to have a single element");
// Match simple binary reductions that can be expressed with atomicrmw.
- Type type = reduce.operand().getType();
+ Type type = reduce.getOperand().getType();
Block &reduction = reduce.getRegion().front();
if (matchSimpleReduction<arith::AddFOp, LLVM::FAddOp>(reduction)) {
omp::ReductionDeclareOp decl = createDecl(builder, symbolTable, reduce,
@@ -335,7 +335,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
{
OpBuilder::InsertionGuard guard(rewriter);
rewriter.setInsertionPointToEnd(parallelOp.getBody());
- assert(llvm::hasSingleElement(parallelOp.region()) &&
+ assert(llvm::hasSingleElement(parallelOp.getRegion()) &&
"expected scf.parallel to have one block");
rewriter.replaceOpWithNewOp<omp::YieldOp>(
parallelOp.getBody()->getTerminator(), ValueRange());
@@ -362,7 +362,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
reductionVariables.reserve(parallelOp.getNumReductions());
Value token = rewriter.create<LLVM::StackSaveOp>(
loc, LLVM::LLVMPointerType::get(rewriter.getIntegerType(8)));
- for (Value init : parallelOp.initVals()) {
+ for (Value init : parallelOp.getInitVals()) {
assert((LLVM::isCompatibleType(init.getType()) ||
init.getType().isa<LLVM::PointerElementTypeInterface>()) &&
"cannot create a reduction variable if the type is not an LLVM "
@@ -382,7 +382,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
scf::ReduceOp reduceOp = std::get<0>(pair);
rewriter.setInsertionPoint(reduceOp);
rewriter.replaceOpWithNewOp<omp::ReductionOp>(
- reduceOp, reduceOp.operand(), std::get<1>(pair));
+ reduceOp, reduceOp.getOperand(), std::get<1>(pair));
}
// Create the parallel wrapper.
@@ -395,7 +395,7 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
{
OpBuilder::InsertionGuard innerGuard(rewriter);
rewriter.setInsertionPointToEnd(parallelOp.getBody());
- assert(llvm::hasSingleElement(parallelOp.region()) &&
+ assert(llvm::hasSingleElement(parallelOp.getRegion()) &&
"expected scf.parallel to have one block");
rewriter.replaceOpWithNewOp<omp::YieldOp>(
parallelOp.getBody()->getTerminator(), ValueRange());
@@ -403,11 +403,11 @@ struct ParallelOpLowering : public OpRewritePattern<scf::ParallelOp> {
// Replace the loop.
auto loop = rewriter.create<omp::WsLoopOp>(
- parallelOp.getLoc(), parallelOp.lowerBound(), parallelOp.upperBound(),
- parallelOp.step());
+ parallelOp.getLoc(), parallelOp.getLowerBound(),
+ parallelOp.getUpperBound(), parallelOp.getStep());
rewriter.create<omp::TerminatorOp>(loc);
- rewriter.inlineRegionBefore(parallelOp.region(), loop.region(),
+ rewriter.inlineRegionBefore(parallelOp.getRegion(), loop.region(),
loop.region().begin());
if (!reductionVariables.empty()) {
loop.reductionsAttr(
diff --git a/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp b/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
index ffa50cac392fa..fd6ec82086206 100644
--- a/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
+++ b/mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp
@@ -177,8 +177,9 @@ ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
loopOp.body().getBlocks().insert(getBlockIt(loopOp.body(), 1), header);
// Create the new induction variable to use.
- BlockArgument newIndVar = header->addArgument(adaptor.lowerBound().getType());
- for (Value arg : adaptor.initArgs())
+ BlockArgument newIndVar =
+ header->addArgument(adaptor.getLowerBound().getType());
+ for (Value arg : adaptor.getInitArgs())
header->addArgument(arg.getType());
Block *body = forOp.getBody();
@@ -198,8 +199,8 @@ ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
rewriter.inlineRegionBefore(forOp->getRegion(0), loopOp.body(),
getBlockIt(loopOp.body(), 2));
- SmallVector<Value, 8> args(1, adaptor.lowerBound());
- args.append(adaptor.initArgs().begin(), adaptor.initArgs().end());
+ SmallVector<Value, 8> args(1, adaptor.getLowerBound());
+ args.append(adaptor.getInitArgs().begin(), adaptor.getInitArgs().end());
// Branch into it from the entry.
rewriter.setInsertionPointToEnd(&(loopOp.body().front()));
rewriter.create<spirv::BranchOp>(loc, header, args);
@@ -208,7 +209,7 @@ ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
rewriter.setInsertionPointToEnd(header);
auto *mergeBlock = loopOp.getMergeBlock();
auto cmpOp = rewriter.create<spirv::SLessThanOp>(
- loc, rewriter.getI1Type(), newIndVar, adaptor.upperBound());
+ loc, rewriter.getI1Type(), newIndVar, adaptor.getUpperBound());
rewriter.create<spirv::BranchConditionalOp>(
loc, cmpOp, body, ArrayRef<Value>(), mergeBlock, ArrayRef<Value>());
@@ -220,7 +221,7 @@ ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
// Add the step to the induction variable and branch to the header.
Value updatedIndVar = rewriter.create<spirv::IAddOp>(
- loc, newIndVar.getType(), newIndVar, adaptor.step());
+ loc, newIndVar.getType(), newIndVar, adaptor.getStep());
rewriter.create<spirv::BranchOp>(loc, header, updatedIndVar);
// Infer the return types from the init operands. Vector type may get
@@ -228,7 +229,7 @@ ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
// extra logic to figure out the right type we just infer it from the Init
// operands.
SmallVector<Type, 8> initTypes;
- for (auto arg : adaptor.initArgs())
+ for (auto arg : adaptor.getInitArgs())
initTypes.push_back(arg.getType());
replaceSCFOutputValue(forOp, loopOp, rewriter, scfToSPIRVContext, initTypes);
return success();
@@ -258,7 +259,7 @@ IfOpConversion::matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
rewriter.createBlock(&selectionOp.body().front());
// Inline `then` region before the merge block and branch to it.
- auto &thenRegion = ifOp.thenRegion();
+ auto &thenRegion = ifOp.getThenRegion();
auto *thenBlock = &thenRegion.front();
rewriter.setInsertionPointToEnd(&thenRegion.back());
rewriter.create<spirv::BranchOp>(loc, mergeBlock);
@@ -267,8 +268,8 @@ IfOpConversion::matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
auto *elseBlock = mergeBlock;
// If `else` region is not empty, inline that region before the merge block
// and branch to it.
- if (!ifOp.elseRegion().empty()) {
- auto &elseRegion = ifOp.elseRegion();
+ if (!ifOp.getElseRegion().empty()) {
+ auto &elseRegion = ifOp.getElseRegion();
elseBlock = &elseRegion.front();
rewriter.setInsertionPointToEnd(&elseRegion.back());
rewriter.create<spirv::BranchOp>(loc, mergeBlock);
@@ -277,12 +278,12 @@ IfOpConversion::matchAndRewrite(scf::IfOp ifOp, OpAdaptor adaptor,
// Create a `spv.BranchConditional` operation for selection header block.
rewriter.setInsertionPointToEnd(selectionHeaderBlock);
- rewriter.create<spirv::BranchConditionalOp>(loc, adaptor.condition(),
+ rewriter.create<spirv::BranchConditionalOp>(loc, adaptor.getCondition(),
thenBlock, ArrayRef<Value>(),
elseBlock, ArrayRef<Value>());
SmallVector<Type, 8> returnTypes;
- for (auto result : ifOp.results()) {
+ for (auto result : ifOp.getResults()) {
auto convertedType = typeConverter.convertType(result.getType());
returnTypes.push_back(convertedType);
}
@@ -342,8 +343,8 @@ WhileOpConversion::matchAndRewrite(scf::WhileOp whileOp, OpAdaptor adaptor,
OpBuilder::InsertionGuard guard(rewriter);
- Region &beforeRegion = whileOp.before();
- Region &afterRegion = whileOp.after();
+ Region &beforeRegion = whileOp.getBefore();
+ Region &afterRegion = whileOp.getAfter();
Block &entryBlock = *loopOp.getEntryBlock();
Block &beforeBlock = beforeRegion.front();
@@ -352,16 +353,16 @@ WhileOpConversion::matchAndRewrite(scf::WhileOp whileOp, OpAdaptor adaptor,
auto cond = cast<scf::ConditionOp>(beforeBlock.getTerminator());
SmallVector<Value> condArgs;
- if (failed(rewriter.getRemappedValues(cond.args(), condArgs)))
+ if (failed(rewriter.getRemappedValues(cond.getArgs(), condArgs)))
return failure();
- Value conditionVal = rewriter.getRemappedValue(cond.condition());
+ Value conditionVal = rewriter.getRemappedValue(cond.getCondition());
if (!conditionVal)
return failure();
auto yield = cast<scf::YieldOp>(afterBlock.getTerminator());
SmallVector<Value> yieldArgs;
- if (failed(rewriter.getRemappedValues(yield.results(), yieldArgs)))
+ if (failed(rewriter.getRemappedValues(yield.getResults(), yieldArgs)))
return failure();
// Move the while before block as the initial loop header block.
@@ -374,7 +375,7 @@ WhileOpConversion::matchAndRewrite(scf::WhileOp whileOp, OpAdaptor adaptor,
// Jump from the loop entry block to the loop header block.
rewriter.setInsertionPointToEnd(&entryBlock);
- rewriter.create<spirv::BranchOp>(loc, &beforeBlock, adaptor.inits());
+ rewriter.create<spirv::BranchOp>(loc, &beforeBlock, adaptor.getInits());
auto condLoc = cond.getLoc();
diff --git a/mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp b/mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp
index 7e9c6983fc664..1994006e88cf1 100644
--- a/mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp
+++ b/mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp
@@ -302,11 +302,11 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp,
// block that has the induction variable and loop-carried values as arguments.
// Split out all operations from the first block into a new block. Move all
// body blocks from the loop body region to the region containing the loop.
- auto *conditionBlock = &forOp.region().front();
+ auto *conditionBlock = &forOp.getRegion().front();
auto *firstBodyBlock =
rewriter.splitBlock(conditionBlock, conditionBlock->begin());
- auto *lastBodyBlock = &forOp.region().back();
- rewriter.inlineRegionBefore(forOp.region(), endBlock);
+ auto *lastBodyBlock = &forOp.getRegion().back();
+ rewriter.inlineRegionBefore(forOp.getRegion(), endBlock);
auto iv = conditionBlock->getArgument(0);
// Append the induction variable stepping logic to the last body block and
@@ -314,7 +314,7 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp,
// operands of the loop terminator.
Operation *terminator = lastBodyBlock->getTerminator();
rewriter.setInsertionPointToEnd(lastBodyBlock);
- auto step = forOp.step();
+ auto step = forOp.getStep();
auto stepped = rewriter.create<arith::AddIOp>(loc, iv, step).getResult();
if (!stepped)
return failure();
@@ -327,8 +327,8 @@ LogicalResult ForLowering::matchAndRewrite(ForOp forOp,
// Compute loop bounds before branching to the condition.
rewriter.setInsertionPointToEnd(initBlock);
- Value lowerBound = forOp.lowerBound();
- Value upperBound = forOp.upperBound();
+ Value lowerBound = forOp.getLowerBound();
+ Value upperBound = forOp.getUpperBound();
if (!lowerBound || !upperBound)
return failure();
@@ -374,7 +374,7 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
// Move blocks from the "then" region to the region containing 'scf.if',
// place it before the continuation block, and branch to it.
- auto &thenRegion = ifOp.thenRegion();
+ auto &thenRegion = ifOp.getThenRegion();
auto *thenBlock = &thenRegion.front();
Operation *thenTerminator = thenRegion.back().getTerminator();
ValueRange thenTerminatorOperands = thenTerminator->getOperands();
@@ -387,7 +387,7 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
// 'scf.if', place it before the continuation block and branch to it. It
// will be placed after the "then" regions.
auto *elseBlock = continueBlock;
- auto &elseRegion = ifOp.elseRegion();
+ auto &elseRegion = ifOp.getElseRegion();
if (!elseRegion.empty()) {
elseBlock = &elseRegion.front();
Operation *elseTerminator = elseRegion.back().getTerminator();
@@ -399,7 +399,7 @@ LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
}
rewriter.setInsertionPointToEnd(condBlock);
- rewriter.create<CondBranchOp>(loc, ifOp.condition(), thenBlock,
+ rewriter.create<CondBranchOp>(loc, ifOp.getCondition(), thenBlock,
/*trueArgs=*/ArrayRef<Value>(), elseBlock,
/*falseArgs=*/ArrayRef<Value>());
@@ -417,7 +417,7 @@ ExecuteRegionLowering::matchAndRewrite(ExecuteRegionOp op,
auto opPosition = rewriter.getInsertionPoint();
auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
- auto ®ion = op.region();
+ auto ®ion = op.getRegion();
rewriter.setInsertionPointToEnd(condBlock);
rewriter.create<BranchOp>(loc, ®ion.front());
@@ -450,14 +450,14 @@ ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
// a further rewrite. If a parallel loop contains reductions (and thus returns
// values), forward the initial values for the reductions down the loop
// hierarchy and bubble up the results by modifying the "yield" terminator.
- SmallVector<Value, 4> iterArgs = llvm::to_vector<4>(parallelOp.initVals());
+ SmallVector<Value, 4> iterArgs = llvm::to_vector<4>(parallelOp.getInitVals());
SmallVector<Value, 4> ivs;
ivs.reserve(parallelOp.getNumLoops());
bool first = true;
SmallVector<Value, 4> loopResults(iterArgs);
for (auto loop_operands :
- llvm::zip(parallelOp.getInductionVars(), parallelOp.lowerBound(),
- parallelOp.upperBound(), parallelOp.step())) {
+ llvm::zip(parallelOp.getInductionVars(), parallelOp.getLowerBound(),
+ parallelOp.getUpperBound(), parallelOp.getStep())) {
Value iv, lower, upper, step;
std::tie(iv, lower, upper, step) = loop_operands;
ForOp forOp = rewriter.create<ForOp>(loc, lower, upper, step, iterArgs);
@@ -488,11 +488,11 @@ ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
if (!reduce)
continue;
- Block &reduceBlock = reduce.reductionOperator().front();
+ Block &reduceBlock = reduce.getReductionOperator().front();
Value arg = iterArgs[yieldOperands.size()];
yieldOperands.push_back(reduceBlock.getTerminator()->getOperand(0));
rewriter.eraseOp(reduceBlock.getTerminator());
- rewriter.mergeBlockBefore(&reduceBlock, &op, {arg, reduce.operand()});
+ rewriter.mergeBlockBefore(&reduceBlock, &op, {arg, reduce.getOperand()});
rewriter.eraseOp(reduce);
}
@@ -528,33 +528,33 @@ LogicalResult WhileLowering::matchAndRewrite(WhileOp whileOp,
rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());
// Inline both regions.
- Block *after = &whileOp.after().front();
- Block *afterLast = &whileOp.after().back();
- Block *before = &whileOp.before().front();
- Block *beforeLast = &whileOp.before().back();
- rewriter.inlineRegionBefore(whileOp.after(), continuation);
- rewriter.inlineRegionBefore(whileOp.before(), after);
+ Block *after = &whileOp.getAfter().front();
+ Block *afterLast = &whileOp.getAfter().back();
+ Block *before = &whileOp.getBefore().front();
+ Block *beforeLast = &whileOp.getBefore().back();
+ rewriter.inlineRegionBefore(whileOp.getAfter(), continuation);
+ rewriter.inlineRegionBefore(whileOp.getBefore(), after);
// Branch to the "before" region.
rewriter.setInsertionPointToEnd(currentBlock);
- rewriter.create<BranchOp>(loc, before, whileOp.inits());
+ rewriter.create<BranchOp>(loc, before, whileOp.getInits());
// Replace terminators with branches. Assuming bodies are SESE, which holds
// given only the patterns from this file, we only need to look at the last
// block. This should be reconsidered if we allow break/continue in SCF.
rewriter.setInsertionPointToEnd(beforeLast);
auto condOp = cast<ConditionOp>(beforeLast->getTerminator());
- rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.condition(), after,
- condOp.args(), continuation,
- ValueRange());
+ rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.getCondition(),
+ after, condOp.getArgs(),
+ continuation, ValueRange());
rewriter.setInsertionPointToEnd(afterLast);
auto yieldOp = cast<scf::YieldOp>(afterLast->getTerminator());
- rewriter.replaceOpWithNewOp<BranchOp>(yieldOp, before, yieldOp.results());
+ rewriter.replaceOpWithNewOp<BranchOp>(yieldOp, before, yieldOp.getResults());
// Replace the op with values "yielded" from the "before" region, which are
// visible by dominance.
- rewriter.replaceOp(whileOp, condOp.args());
+ rewriter.replaceOp(whileOp, condOp.getArgs());
return success();
}
@@ -562,19 +562,19 @@ LogicalResult WhileLowering::matchAndRewrite(WhileOp whileOp,
LogicalResult
DoWhileLowering::matchAndRewrite(WhileOp whileOp,
PatternRewriter &rewriter) const {
- if (!llvm::hasSingleElement(whileOp.after()))
+ if (!llvm::hasSingleElement(whileOp.getAfter()))
return rewriter.notifyMatchFailure(whileOp,
"do-while simplification applicable to "
"single-block 'after' region only");
- Block &afterBlock = whileOp.after().front();
+ Block &afterBlock = whileOp.getAfter().front();
if (!llvm::hasSingleElement(afterBlock))
return rewriter.notifyMatchFailure(whileOp,
"do-while simplification applicable "
"only if 'after' region has no payload");
auto yield = dyn_cast<scf::YieldOp>(&afterBlock.front());
- if (!yield || yield.results() != afterBlock.getArguments())
+ if (!yield || yield.getResults() != afterBlock.getArguments())
return rewriter.notifyMatchFailure(whileOp,
"do-while simplification applicable "
"only to forwarding 'after' regions");
@@ -586,24 +586,24 @@ DoWhileLowering::matchAndRewrite(WhileOp whileOp,
rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());
// Only the "before" region should be inlined.
- Block *before = &whileOp.before().front();
- Block *beforeLast = &whileOp.before().back();
- rewriter.inlineRegionBefore(whileOp.before(), continuation);
+ Block *before = &whileOp.getBefore().front();
+ Block *beforeLast = &whileOp.getBefore().back();
+ rewriter.inlineRegionBefore(whileOp.getBefore(), continuation);
// Branch to the "before" region.
rewriter.setInsertionPointToEnd(currentBlock);
- rewriter.create<BranchOp>(whileOp.getLoc(), before, whileOp.inits());
+ rewriter.create<BranchOp>(whileOp.getLoc(), before, whileOp.getInits());
// Loop around the "before" region based on condition.
rewriter.setInsertionPointToEnd(beforeLast);
auto condOp = cast<ConditionOp>(beforeLast->getTerminator());
- rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.condition(), before,
- condOp.args(), continuation,
- ValueRange());
+ rewriter.replaceOpWithNewOp<CondBranchOp>(condOp, condOp.getCondition(),
+ before, condOp.getArgs(),
+ continuation, ValueRange());
// Replace the op with values "yielded" from the "before" region, which are
// visible by dominance.
- rewriter.replaceOp(whileOp, condOp.args());
+ rewriter.replaceOp(whileOp, condOp.getArgs());
return success();
}
diff --git a/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp b/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp
index deb4cd502ab98..7e0c4a7c5cd4a 100644
--- a/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp
+++ b/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp
@@ -318,7 +318,7 @@ LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
b.create<scf::YieldOp>(loc, broadcastable);
});
- rewriter.replaceOp(op, reduceResult.results().front());
+ rewriter.replaceOp(op, reduceResult.getResults().front());
return success();
}
diff --git a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
index 78981fd097158..f05226d6a4645 100644
--- a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
+++ b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp
@@ -329,12 +329,12 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
SmallVector<Type> types = {elementTy, elementTy, elementTy};
auto whileOp = rewriter.create<scf::WhileOp>(loc, types, operands);
- Block *before = rewriter.createBlock(&whileOp.before(), {}, types);
- Block *after = rewriter.createBlock(&whileOp.after(), {}, types);
+ Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, types);
+ Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, types);
// The conditional block of the while loop.
{
- rewriter.setInsertionPointToStart(&whileOp.before().front());
+ rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
Value input = before->getArgument(0);
Value zero = before->getArgument(2);
@@ -346,7 +346,7 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args,
// The body of the while loop: shift right until reaching a value of 0.
{
- rewriter.setInsertionPointToStart(&whileOp.after().front());
+ rewriter.setInsertionPointToStart(&whileOp.getAfter().front());
Value input = after->getArgument(0);
Value leadingZeros = after->getArgument(1);
diff --git a/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp b/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp
index ef5ccf93765b5..2cf226b7285fb 100644
--- a/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp
+++ b/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp
@@ -72,8 +72,10 @@ class IfOpConverter : public OpRewritePattern<tosa::IfOp> {
auto newIf = rewriter.create<scf::IfOp>(op.getLoc(), op.getResultTypes(),
condition, true);
- inlineIfCase(op.then_branch(), newIf.thenRegion(), op.inputs(), rewriter);
- inlineIfCase(op.else_branch(), newIf.elseRegion(), op.inputs(), rewriter);
+ inlineIfCase(op.then_branch(), newIf.getThenRegion(), op.inputs(),
+ rewriter);
+ inlineIfCase(op.else_branch(), newIf.getElseRegion(), op.inputs(),
+ rewriter);
rewriter.replaceOp(op, newIf.getResults());
return success();
@@ -88,11 +90,11 @@ class WhileOpConverter : public OpRewritePattern<tosa::WhileOp> {
PatternRewriter &rewriter) const final {
auto newWhile = rewriter.create<scf::WhileOp>(
op.getLoc(), op.getResultTypes(), op.inputs());
- rewriter.createBlock(&newWhile.before());
- rewriter.createBlock(&newWhile.after());
+ rewriter.createBlock(&newWhile.getBefore());
+ rewriter.createBlock(&newWhile.getAfter());
- inlineWhileCase(op.cond(), newWhile.before(), rewriter, true);
- inlineWhileCase(op.body(), newWhile.after(), rewriter, false);
+ inlineWhileCase(op.cond(), newWhile.getBefore(), rewriter, true);
+ inlineWhileCase(op.body(), newWhile.getAfter(), rewriter, false);
rewriter.replaceOp(op, newWhile.getResults());
diff --git a/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp b/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
index 4c50b4f699365..985cfc9b91e24 100644
--- a/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
+++ b/mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp
@@ -431,8 +431,8 @@ static scf::ForOp replaceForOpWithNewSignature(OpBuilder &b, scf::ForOp loop,
auto operands = llvm::to_vector<4>(loop.getIterOperands());
operands.append(newIterOperands.begin(), newIterOperands.end());
scf::ForOp newLoop =
- b.create<scf::ForOp>(loop.getLoc(), loop.lowerBound(), loop.upperBound(),
- loop.step(), operands);
+ b.create<scf::ForOp>(loop.getLoc(), loop.getLowerBound(),
+ loop.getUpperBound(), loop.getStep(), operands);
newLoop.getBody()->erase();
newLoop.getLoopBody().getBlocks().splice(
newLoop.getLoopBody().getBlocks().begin(),
diff --git a/mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp b/mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp
index ec503533a332c..f0b4244c9f4fc 100644
--- a/mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp
+++ b/mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp
@@ -209,7 +209,7 @@ static ParallelComputeFunctionType
getParallelComputeFunctionType(scf::ParallelOp op, PatternRewriter &rewriter) {
// Values implicitly captured by the parallel operation.
llvm::SetVector<Value> captures;
- getUsedValuesDefinedAbove(op.region(), op.region(), captures);
+ getUsedValuesDefinedAbove(op.getRegion(), op.getRegion(), captures);
SmallVector<Type> inputs;
inputs.reserve(2 + 4 * op.getNumLoops() + captures.size());
@@ -500,8 +500,8 @@ static FuncOp createAsyncDispatchFunction(ParallelComputeFunction &computeFunc,
// Create a recursive dispatch loop.
scf::WhileOp whileOp = b.create<scf::WhileOp>(types, operands);
- Block *before = b.createBlock(&whileOp.before(), {}, types);
- Block *after = b.createBlock(&whileOp.after(), {}, types);
+ Block *before = b.createBlock(&whileOp.getBefore(), {}, types);
+ Block *after = b.createBlock(&whileOp.getAfter(), {}, types);
// Setup dispatch loop condition block: decide if we need to go into the
// `after` block and launch one more async dispatch.
@@ -582,9 +582,9 @@ static void doAsyncDispatch(ImplicitLocOpBuilder &b, PatternRewriter &rewriter,
// the given operands vector.
auto appendBlockComputeOperands = [&](SmallVector<Value> &operands) {
operands.append(tripCounts);
- operands.append(op.lowerBound().begin(), op.lowerBound().end());
- operands.append(op.upperBound().begin(), op.upperBound().end());
- operands.append(op.step().begin(), op.step().end());
+ operands.append(op.getLowerBound().begin(), op.getLowerBound().end());
+ operands.append(op.getUpperBound().begin(), op.getUpperBound().end());
+ operands.append(op.getStep().begin(), op.getStep().end());
operands.append(parallelComputeFunction.captures);
};
@@ -661,9 +661,11 @@ doSequentialDispatch(ImplicitLocOpBuilder &b, PatternRewriter &rewriter,
auto computeFuncOperands = [&](Value blockIndex) -> SmallVector<Value> {
SmallVector<Value> computeFuncOperands = {blockIndex, blockSize};
computeFuncOperands.append(tripCounts);
- computeFuncOperands.append(op.lowerBound().begin(), op.lowerBound().end());
- computeFuncOperands.append(op.upperBound().begin(), op.upperBound().end());
- computeFuncOperands.append(op.step().begin(), op.step().end());
+ computeFuncOperands.append(op.getLowerBound().begin(),
+ op.getLowerBound().end());
+ computeFuncOperands.append(op.getUpperBound().begin(),
+ op.getUpperBound().end());
+ computeFuncOperands.append(op.getStep().begin(), op.getStep().end());
computeFuncOperands.append(parallelComputeFunction.captures);
return computeFuncOperands;
};
@@ -722,9 +724,9 @@ AsyncParallelForRewrite::matchAndRewrite(scf::ParallelOp op,
// tripCount = ceil_div(upperBound - lowerBound, step);
SmallVector<Value> tripCounts(op.getNumLoops());
for (size_t i = 0; i < op.getNumLoops(); ++i) {
- auto lb = op.lowerBound()[i];
- auto ub = op.upperBound()[i];
- auto step = op.step()[i];
+ auto lb = op.getLowerBound()[i];
+ auto ub = op.getUpperBound()[i];
+ auto step = op.getStep()[i];
auto range = b.createOrFold<arith::SubIOp>(ub, lb);
tripCounts[i] = b.createOrFold<arith::CeilDivSIOp>(range, step);
}
@@ -758,9 +760,9 @@ AsyncParallelForRewrite::matchAndRewrite(scf::ParallelOp op,
// folding, loop unrolling and vectorization.
ParallelComputeFunctionBounds staticBounds = {
integerConstants(tripCounts),
- integerConstants(op.lowerBound()),
- integerConstants(op.upperBound()),
- integerConstants(op.step()),
+ integerConstants(op.getLowerBound()),
+ integerConstants(op.getUpperBound()),
+ integerConstants(op.getStep()),
};
// Find how many inner iteration dimensions are statically known, and their
diff --git a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp
index f3e4aa4d9c98e..8a2630c29b7f3 100644
--- a/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp
+++ b/mlir/lib/Dialect/Linalg/ComprehensiveBufferize/SCFInterfaceImpl.cpp
@@ -32,10 +32,10 @@ struct ExecuteRegionOpInterface
auto executeRegionOp = cast<scf::ExecuteRegionOp>(op);
size_t resultNum = std::distance(op->getOpResults().begin(),
llvm::find(op->getOpResults(), opResult));
- assert(executeRegionOp.region().getBlocks().size() == 1 &&
+ assert(executeRegionOp.getRegion().getBlocks().size() == 1 &&
"expected exactly 1 block");
auto yieldOp = dyn_cast<scf::YieldOp>(
- executeRegionOp.region().front().getTerminator());
+ executeRegionOp.getRegion().front().getTerminator());
assert(yieldOp && "expected scf.yield terminator in scf.execute_region");
return {&yieldOp->getOpOperand(resultNum)};
}
@@ -70,7 +70,8 @@ struct ExecuteRegionOpInterface
if (hasTensorReturnType)
return op->emitError(
"scf.execute_region with tensor result not supported");
- return comprehensive_bufferize::bufferize(&executeRegionOp.region(), state);
+ return comprehensive_bufferize::bufferize(&executeRegionOp.getRegion(),
+ state);
}
BufferRelation bufferRelation(Operation *op, OpResult opResult,
@@ -158,7 +159,7 @@ struct IfOpInterface
// Create new op.
auto newIfOp =
- rewriter.create<scf::IfOp>(ifOp.getLoc(), newTypes, ifOp.condition(),
+ rewriter.create<scf::IfOp>(ifOp.getLoc(), newTypes, ifOp.getCondition(),
/*withElseRegion=*/true);
// Remove terminators.
@@ -288,7 +289,7 @@ struct ForOpInterface
// Indices of all iter_args that have tensor type. These are the ones that
// are bufferized.
DenseSet<int64_t> indices;
- for (const auto &it : llvm::enumerate(forOp.initArgs()))
+ for (const auto &it : llvm::enumerate(forOp.getInitArgs()))
if (it.value().getType().isa<TensorType>())
indices.insert(it.index());
@@ -307,12 +308,12 @@ struct ForOpInterface
// Construct a new scf.for op with memref instead of tensor values.
SmallVector<Value> initArgs =
- convert(forOp.initArgs(), [&](Value val, int64_t index) {
+ convert(forOp.getInitArgs(), [&](Value val, int64_t index) {
return state.getResultBuffer(forOp->getOpResult(index));
});
- auto newForOp =
- rewriter.create<scf::ForOp>(forOp.getLoc(), forOp.lowerBound(),
- forOp.upperBound(), forOp.step(), initArgs);
+ auto newForOp = rewriter.create<scf::ForOp>(
+ forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
+ forOp.getStep(), initArgs);
Block *loopBody = &newForOp.getLoopBody().front();
// Set up new iter_args. The loop body uses tensors, so wrap the (memref)
@@ -335,11 +336,11 @@ struct ForOpInterface
auto yieldOp = cast<scf::YieldOp>(loopBody->getTerminator());
rewriter.setInsertionPoint(yieldOp);
SmallVector<Value> yieldValues =
- convert(yieldOp.results(), [&](Value val, int64_t index) {
+ convert(yieldOp.getResults(), [&](Value val, int64_t index) {
return rewriter.create<bufferization::ToMemrefOp>(
val.getLoc(), initArgs[index].getType(), val);
});
- yieldOp.resultsMutable().assign(yieldValues);
+ yieldOp.getResultsMutable().assign(yieldValues);
// Replace loop results.
state.replaceOp(op, newForOp->getResults());
diff --git a/mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp b/mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp
index 7abcc8a943b4f..a4edd8a87bba7 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/HoistPadding.cpp
@@ -331,7 +331,7 @@ HoistingAnalysis::getPackedTensorSizes(ImplicitLocOpBuilder &b) {
// Compute an upper bound `ubVal` for the upper bound of `forOp`.
AffineMap boundMap;
SmallVector<Value> boundOperands;
- getUpperBoundForIndex(forOp.upperBound(), boundMap, boundOperands);
+ getUpperBoundForIndex(forOp.getUpperBound(), boundMap, boundOperands);
Value ubVal = b.createOrFold<AffineMinOp>(boundMap, boundOperands);
// Compute the maximal packing loop length as (ub - lb).ceilDiv(step) and
// store the result to `dynamicTensorSizes`.
@@ -341,8 +341,8 @@ HoistingAnalysis::getPackedTensorSizes(ImplicitLocOpBuilder &b) {
bindDims(b.getContext(), lb, ub);
bindSymbols(b.getContext(), step);
Value res = b.createOrFold<AffineApplyOp>(
- (ub - lb).ceilDiv(step),
- ValueRange{forOp.lowerBound(), ubVal, cast<scf::ForOp>(forOp).step()});
+ (ub - lb).ceilDiv(step), ValueRange{forOp.getLowerBound(), ubVal,
+ cast<scf::ForOp>(forOp).getStep()});
dynamicTensorSizes.push_back(res);
}
@@ -363,11 +363,11 @@ static Value buildLoopIterationCount(OpBuilder &b, scf::ForOp outer,
AffineExpr iv, lb, step;
bindDims(ctx, iv, lb);
bindSymbols(ctx, step);
- if (!isDefinedOutsideOrConstant(outer, forOp.lowerBound()) ||
- !isDefinedOutsideOrConstant(outer, forOp.step()))
+ if (!isDefinedOutsideOrConstant(outer, forOp.getLowerBound()) ||
+ !isDefinedOutsideOrConstant(outer, forOp.getStep()))
return Value();
- Value ivVal = forOp.getInductionVar(), lbVal = forOp.lowerBound(),
- stepVal = forOp.step();
+ Value ivVal = forOp.getInductionVar(), lbVal = forOp.getLowerBound(),
+ stepVal = forOp.getStep();
auto loc = forOp->getLoc();
return b.createOrFold<AffineApplyOp>(loc, (iv - lb).ceilDiv(step),
ValueRange{ivVal, lbVal, stepVal});
@@ -434,10 +434,10 @@ FailureOr<Value> mlir::linalg::hoistPaddingOnTensors(PadTensorOp opToHoist,
continue;
}
// Create a packing loop that takes `packedTensor` as iteration argument.
- auto clonedForOp =
- b.create<scf::ForOp>(loc, bvm.lookupOrDefault(forOp.lowerBound()),
- bvm.lookupOrDefault(forOp.upperBound()),
- bvm.lookupOrDefault(forOp.step()), packedTensor);
+ auto clonedForOp = b.create<scf::ForOp>(
+ loc, bvm.lookupOrDefault(forOp.getLowerBound()),
+ bvm.lookupOrDefault(forOp.getUpperBound()),
+ bvm.lookupOrDefault(forOp.getStep()), packedTensor);
// Map the induction var, region args and results to the `clonedForOp`.
bvm.map(forOp.getInductionVar(), clonedForOp.getInductionVar());
bvm.map(forOp.getRegionIterArgs(), clonedForOp.getRegionIterArgs());
diff --git a/mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp b/mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp
index eefc51d9d34db..97b586cdf762d 100644
--- a/mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp
+++ b/mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp
@@ -286,9 +286,11 @@ static void hoistReadWrite(HoistableRead read, HoistableWrite write,
// Update the source tensor.
if (read.extractSliceOp)
- read.extractSliceOp.sourceMutable().assign(forOp.initArgs()[initArgNumber]);
+ read.extractSliceOp.sourceMutable().assign(
+ forOp.getInitArgs()[initArgNumber]);
else
- read.transferReadOp.sourceMutable().assign(forOp.initArgs()[initArgNumber]);
+ read.transferReadOp.sourceMutable().assign(
+ forOp.getInitArgs()[initArgNumber]);
// Hoist write after.
if (write.insertSliceOp)
@@ -296,7 +298,7 @@ static void hoistReadWrite(HoistableRead read, HoistableWrite write,
write.transferWriteOp->moveAfter(forOp);
// Update the yield.
- auto yieldOp = cast<scf::YieldOp>(forOp.region().front().getTerminator());
+ auto yieldOp = cast<scf::YieldOp>(forOp.getRegion().front().getTerminator());
if (write.insertSliceOp)
yieldOp->setOperand(initArgNumber, write.insertSliceOp.dest());
else
diff --git a/mlir/lib/Dialect/SCF/SCF.cpp b/mlir/lib/Dialect/SCF/SCF.cpp
index cea88d1e52a66..95a4c9d718685 100644
--- a/mlir/lib/Dialect/SCF/SCF.cpp
+++ b/mlir/lib/Dialect/SCF/SCF.cpp
@@ -118,7 +118,7 @@ static ParseResult parseExecuteRegionOp(OpAsmParser &parser,
static void print(OpAsmPrinter &p, ExecuteRegionOp op) {
p.printOptionalArrowTypeList(op.getResultTypes());
- p.printRegion(op.region(),
+ p.printRegion(op.getRegion(),
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/true);
@@ -126,9 +126,9 @@ static void print(OpAsmPrinter &p, ExecuteRegionOp op) {
}
static LogicalResult verify(ExecuteRegionOp op) {
- if (op.region().empty())
+ if (op.getRegion().empty())
return op.emitOpError("region needs to have at least one block");
- if (op.region().front().getNumArguments() > 0)
+ if (op.getRegion().front().getNumArguments() > 0)
return op.emitOpError("region cannot have any arguments");
return success();
}
@@ -152,9 +152,9 @@ struct SingleBlockExecuteInliner : public OpRewritePattern<ExecuteRegionOp> {
LogicalResult matchAndRewrite(ExecuteRegionOp op,
PatternRewriter &rewriter) const override {
- if (!llvm::hasSingleElement(op.region()))
+ if (!llvm::hasSingleElement(op.getRegion()))
return failure();
- replaceOpWithRegion(rewriter, op, op.region());
+ replaceOpWithRegion(rewriter, op, op.getRegion());
return success();
}
};
@@ -208,18 +208,18 @@ struct MultiBlockExecuteInliner : public OpRewritePattern<ExecuteRegionOp> {
Block *postBlock = rewriter.splitBlock(prevBlock, op->getIterator());
rewriter.setInsertionPointToEnd(prevBlock);
- rewriter.create<BranchOp>(op.getLoc(), &op.region().front());
+ rewriter.create<BranchOp>(op.getLoc(), &op.getRegion().front());
- for (Block &blk : op.region()) {
+ for (Block &blk : op.getRegion()) {
if (YieldOp yieldOp = dyn_cast<YieldOp>(blk.getTerminator())) {
rewriter.setInsertionPoint(yieldOp);
rewriter.create<BranchOp>(yieldOp.getLoc(), postBlock,
- yieldOp.results());
+ yieldOp.getResults());
rewriter.eraseOp(yieldOp);
}
}
- rewriter.inlineRegionBefore(op.region(), postBlock);
+ rewriter.inlineRegionBefore(op.getRegion(), postBlock);
SmallVector<Value> blockArgs;
for (auto res : op.getResults())
@@ -242,7 +242,7 @@ void ExecuteRegionOp::getCanonicalizationPatterns(RewritePatternSet &results,
MutableOperandRange
ConditionOp::getMutableSuccessorOperands(Optional<unsigned> index) {
// Pass all operands except the condition to the successor region.
- return argsMutable();
+ return getArgsMutable();
}
//===----------------------------------------------------------------------===//
@@ -277,7 +277,7 @@ void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
}
static LogicalResult verify(ForOp op) {
- if (auto cst = op.step().getDefiningOp<arith::ConstantIndexOp>())
+ if (auto cst = op.getStep().getDefiningOp<arith::ConstantIndexOp>())
if (cst.value() <= 0)
return op.emitOpError("constant step operand must be positive");
@@ -340,14 +340,14 @@ static void printInitializationList(OpAsmPrinter &p,
}
static void print(OpAsmPrinter &p, ForOp op) {
- p << " " << op.getInductionVar() << " = " << op.lowerBound() << " to "
- << op.upperBound() << " step " << op.step();
+ p << " " << op.getInductionVar() << " = " << op.getLowerBound() << " to "
+ << op.getUpperBound() << " step " << op.getStep();
printInitializationList(p, op.getRegionIterArgs(), op.getIterOperands(),
" iter_args");
if (!op.getIterOperands().empty())
p << " -> (" << op.getIterOperands().getTypes() << ')';
- p.printRegion(op.region(),
+ p.printRegion(op.getRegion(),
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/op.hasIterOperands());
p.printOptionalAttrDict(op->getAttrs());
@@ -409,10 +409,10 @@ static ParseResult parseForOp(OpAsmParser &parser, OperationState &result) {
return success();
}
-Region &ForOp::getLoopBody() { return region(); }
+Region &ForOp::getLoopBody() { return getRegion(); }
bool ForOp::isDefinedOutsideOfLoop(Value value) {
- return !region().isAncestor(value.getParentRegion());
+ return !getRegion().isAncestor(value.getParentRegion());
}
LogicalResult ForOp::moveOutOfLoop(ArrayRef<Operation *> ops) {
@@ -439,7 +439,7 @@ OperandRange ForOp::getSuccessorEntryOperands(unsigned index) {
// The initial operands map to the loop arguments after the induction
// variable.
- return initArgs();
+ return getInitArgs();
}
/// Given the region at `index`, or the parent operation if `index` is None,
@@ -591,7 +591,7 @@ struct ForOpIterArgsFolder : public OpRewritePattern<scf::ForOp> {
LogicalResult matchAndRewrite(scf::ForOp forOp,
PatternRewriter &rewriter) const final {
bool canonicalize = false;
- Block &block = forOp.region().front();
+ Block &block = forOp.getRegion().front();
auto yieldOp = cast<scf::YieldOp>(block.getTerminator());
// An internal flat vector of block transfer
@@ -640,9 +640,9 @@ struct ForOpIterArgsFolder : public OpRewritePattern<scf::ForOp> {
return failure();
scf::ForOp newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.lowerBound(), forOp.upperBound(), forOp.step(),
- newIterArgs);
- Block &newBlock = newForOp.region().front();
+ forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
+ forOp.getStep(), newIterArgs);
+ Block &newBlock = newForOp.getRegion().front();
// Replace the null placeholders with newly constructed values.
newBlockTransferArgs[0] = newBlock.getArgument(0); // iv
@@ -658,7 +658,7 @@ struct ForOpIterArgsFolder : public OpRewritePattern<scf::ForOp> {
}
}
- Block &oldBlock = forOp.region().front();
+ Block &oldBlock = forOp.getRegion().front();
assert(oldBlock.getNumArguments() == newBlockTransferArgs.size() &&
"unexpected argument size mismatch");
@@ -704,13 +704,13 @@ struct SimplifyTrivialLoops : public OpRewritePattern<ForOp> {
PatternRewriter &rewriter) const override {
// If the upper bound is the same as the lower bound, the loop does not
// iterate, just remove it.
- if (op.lowerBound() == op.upperBound()) {
+ if (op.getLowerBound() == op.getUpperBound()) {
rewriter.replaceOp(op, op.getIterOperands());
return success();
}
- auto lb = op.lowerBound().getDefiningOp<arith::ConstantOp>();
- auto ub = op.upperBound().getDefiningOp<arith::ConstantOp>();
+ auto lb = op.getLowerBound().getDefiningOp<arith::ConstantOp>();
+ auto ub = op.getUpperBound().getDefiningOp<arith::ConstantOp>();
if (!lb || !ub)
return failure();
@@ -722,7 +722,7 @@ struct SimplifyTrivialLoops : public OpRewritePattern<ForOp> {
return success();
}
- auto step = op.step().getDefiningOp<arith::ConstantOp>();
+ auto step = op.getStep().getDefiningOp<arith::ConstantOp>();
if (!step)
return failure();
@@ -732,7 +732,7 @@ struct SimplifyTrivialLoops : public OpRewritePattern<ForOp> {
if ((lbValue + stepValue).sge(ubValue)) {
SmallVector<Value, 4> blockArgs;
blockArgs.reserve(op.getNumIterOperands() + 1);
- blockArgs.push_back(op.lowerBound());
+ blockArgs.push_back(op.getLowerBound());
llvm::append_range(blockArgs, op.getIterOperands());
replaceOpWithRegion(rewriter, op, op.getLoopBody(), blockArgs);
return success();
@@ -769,9 +769,9 @@ static ForOp replaceTensorCastForOpIterArg(PatternRewriter &rewriter,
// 2. Create the new forOp shell.
scf::ForOp newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.lowerBound(), forOp.upperBound(), forOp.step(),
- newIterOperands);
- Block &newBlock = newForOp.region().front();
+ forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
+ forOp.getStep(), newIterOperands);
+ Block &newBlock = newForOp.getRegion().front();
SmallVector<Value, 4> newBlockTransferArgs(newBlock.getArguments().begin(),
newBlock.getArguments().end());
@@ -786,7 +786,7 @@ static ForOp replaceTensorCastForOpIterArg(PatternRewriter &rewriter,
newBlockTransferArgs[newRegionIterArg.getArgNumber()] = castIn;
// 4. Steal the old block ops, mapping to the newBlockTransferArgs.
- Block &oldBlock = forOp.region().front();
+ Block &oldBlock = forOp.getRegion().front();
rewriter.mergeBlocks(&oldBlock, &newBlock, newBlockTransferArgs);
// 5. Inject an outgoing cast op at the end of the block and yield it instead.
@@ -931,14 +931,15 @@ struct LastTensorLoadCanonicalization : public OpRewritePattern<ForOp> {
LogicalResult matchAndRewrite(ForOp forOp,
PatternRewriter &rewriter) const override {
- assert(std::next(forOp.region().begin()) == forOp.region().end() &&
+ assert(std::next(forOp.getRegion().begin()) == forOp.getRegion().end() &&
"unexpected multiple blocks");
Location loc = forOp.getLoc();
DenseMap<Value, Value> replacements;
for (BlockArgument bbArg : forOp.getRegionIterArgs()) {
unsigned idx = bbArg.getArgNumber() - /*numIv=*/1;
- auto yieldOp = cast<scf::YieldOp>(forOp.region().front().getTerminator());
+ auto yieldOp =
+ cast<scf::YieldOp>(forOp.getRegion().front().getTerminator());
Value yieldVal = yieldOp->getOperand(idx);
auto tensorLoadOp = yieldVal.getDefiningOp<bufferization::ToTensorOp>();
bool isTensor = bbArg.getType().isa<TensorType>();
@@ -1081,7 +1082,7 @@ void IfOp::build(OpBuilder &builder, OperationState &result, Value cond,
}
static LogicalResult verify(IfOp op) {
- if (op.getNumResults() != 0 && op.elseRegion().empty())
+ if (op.getNumResults() != 0 && op.getElseRegion().empty())
return op.emitOpError("must have an else block if defining values");
return RegionBranchOpInterface::verifyTypes(op);
@@ -1123,18 +1124,18 @@ static ParseResult parseIfOp(OpAsmParser &parser, OperationState &result) {
static void print(OpAsmPrinter &p, IfOp op) {
bool printBlockTerminators = false;
- p << " " << op.condition();
- if (!op.results().empty()) {
+ p << " " << op.getCondition();
+ if (!op.getResults().empty()) {
p << " -> (" << op.getResultTypes() << ")";
// Print yield explicitly if the op defines values.
printBlockTerminators = true;
}
- p.printRegion(op.thenRegion(),
+ p.printRegion(op.getThenRegion(),
/*printEntryBlockArgs=*/false,
/*printBlockTerminators=*/printBlockTerminators);
// Print the 'else' regions if it exists and has a block.
- auto &elseRegion = op.elseRegion();
+ auto &elseRegion = op.getElseRegion();
if (!elseRegion.empty()) {
p << " else";
p.printRegion(elseRegion,
@@ -1160,7 +1161,7 @@ void IfOp::getSuccessorRegions(Optional<unsigned> index,
}
// Don't consider the else region if it is empty.
- Region *elseRegion = &this->elseRegion();
+ Region *elseRegion = &this->getElseRegion();
if (elseRegion->empty())
elseRegion = nullptr;
@@ -1170,7 +1171,7 @@ void IfOp::getSuccessorRegions(Optional<unsigned> index,
condition = condAttr.getValue().isOneValue();
} else {
// If the condition isn't constant, both regions may be executed.
- regions.push_back(RegionSuccessor(&thenRegion()));
+ regions.push_back(RegionSuccessor(&getThenRegion()));
// If the else region does not exist, it is not a viable successor.
if (elseRegion)
regions.push_back(RegionSuccessor(elseRegion));
@@ -1178,7 +1179,7 @@ void IfOp::getSuccessorRegions(Optional<unsigned> index,
}
// Add the successor regions using the condition.
- regions.push_back(RegionSuccessor(condition ? &thenRegion() : elseRegion));
+ regions.push_back(RegionSuccessor(condition ? &getThenRegion() : elseRegion));
}
/// If the condition is a constant, returns 1 for the executed block and 0 for
@@ -1236,7 +1237,7 @@ struct RemoveUnusedResults : public OpRewritePattern<IfOp> {
// Create a replacement operation with empty then and else regions.
auto emptyBuilder = [](OpBuilder &, Location) {};
- auto newOp = rewriter.create<IfOp>(op.getLoc(), newTypes, op.condition(),
+ auto newOp = rewriter.create<IfOp>(op.getLoc(), newTypes, op.getCondition(),
emptyBuilder, emptyBuilder);
// Move the bodies and replace the terminators (note there is a then and
@@ -1258,14 +1259,14 @@ struct RemoveStaticCondition : public OpRewritePattern<IfOp> {
LogicalResult matchAndRewrite(IfOp op,
PatternRewriter &rewriter) const override {
- auto constant = op.condition().getDefiningOp<arith::ConstantOp>();
+ auto constant = op.getCondition().getDefiningOp<arith::ConstantOp>();
if (!constant)
return failure();
if (constant.getValue().cast<BoolAttr>().getValue())
- replaceOpWithRegion(rewriter, op, op.thenRegion());
- else if (!op.elseRegion().empty())
- replaceOpWithRegion(rewriter, op, op.elseRegion());
+ replaceOpWithRegion(rewriter, op, op.getThenRegion());
+ else if (!op.getElseRegion().empty())
+ replaceOpWithRegion(rewriter, op, op.getElseRegion());
else
rewriter.eraseOp(op);
@@ -1281,16 +1282,16 @@ struct ConvertTrivialIfToSelect : public OpRewritePattern<IfOp> {
if (op->getNumResults() == 0)
return failure();
- if (!llvm::hasSingleElement(op.thenRegion().front()) ||
- !llvm::hasSingleElement(op.elseRegion().front()))
+ if (!llvm::hasSingleElement(op.getThenRegion().front()) ||
+ !llvm::hasSingleElement(op.getElseRegion().front()))
return failure();
- auto cond = op.condition();
+ auto cond = op.getCondition();
auto thenYieldArgs =
- cast<scf::YieldOp>(op.thenRegion().front().getTerminator())
+ cast<scf::YieldOp>(op.getThenRegion().front().getTerminator())
.getOperands();
auto elseYieldArgs =
- cast<scf::YieldOp>(op.elseRegion().front().getTerminator())
+ cast<scf::YieldOp>(op.getElseRegion().front().getTerminator())
.getOperands();
SmallVector<Value> results(op->getNumResults());
assert(thenYieldArgs.size() == results.size());
@@ -1330,7 +1331,7 @@ struct ConditionPropagation : public OpRewritePattern<IfOp> {
PatternRewriter &rewriter) const override {
// Early exit if the condition is constant since replacing a constant
// in the body with another constant isn't a simplification.
- if (op.condition().getDefiningOp<arith::ConstantOp>())
+ if (op.getCondition().getDefiningOp<arith::ConstantOp>())
return failure();
bool changed = false;
@@ -1342,8 +1343,8 @@ struct ConditionPropagation : public OpRewritePattern<IfOp> {
Value constantFalse = nullptr;
for (OpOperand &use :
- llvm::make_early_inc_range(op.condition().getUses())) {
- if (op.thenRegion().isAncestor(use.getOwner()->getParentRegion())) {
+ llvm::make_early_inc_range(op.getCondition().getUses())) {
+ if (op.getThenRegion().isAncestor(use.getOwner()->getParentRegion())) {
changed = true;
if (!constantTrue)
@@ -1352,7 +1353,7 @@ struct ConditionPropagation : public OpRewritePattern<IfOp> {
rewriter.updateRootInPlace(use.getOwner(),
[&]() { use.set(constantTrue); });
- } else if (op.elseRegion().isAncestor(
+ } else if (op.getElseRegion().isAncestor(
use.getOwner()->getParentRegion())) {
changed = true;
@@ -1414,16 +1415,17 @@ struct ReplaceIfYieldWithConditionOrValue : public OpRewritePattern<IfOp> {
if (op.getNumResults() == 0)
return failure();
- auto trueYield = cast<scf::YieldOp>(op.thenRegion().back().getTerminator());
+ auto trueYield =
+ cast<scf::YieldOp>(op.getThenRegion().back().getTerminator());
auto falseYield =
- cast<scf::YieldOp>(op.elseRegion().back().getTerminator());
+ cast<scf::YieldOp>(op.getElseRegion().back().getTerminator());
rewriter.setInsertionPoint(op->getBlock(),
op.getOperation()->getIterator());
bool changed = false;
Type i1Ty = rewriter.getI1Type();
- for (auto tup :
- llvm::zip(trueYield.results(), falseYield.results(), op.results())) {
+ for (auto tup : llvm::zip(trueYield.getResults(), falseYield.getResults(),
+ op.getResults())) {
Value trueResult, falseResult, opResult;
std::tie(trueResult, falseResult, opResult) = tup;
@@ -1451,7 +1453,7 @@ struct ReplaceIfYieldWithConditionOrValue : public OpRewritePattern<IfOp> {
if (!trueVal && falseVal) {
if (!opResult.use_empty()) {
Value notCond = rewriter.create<arith::XOrIOp>(
- op.getLoc(), op.condition(),
+ op.getLoc(), op.getCondition(),
rewriter.create<arith::ConstantOp>(
op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 1)));
opResult.replaceAllUsesWith(notCond);
@@ -1460,7 +1462,7 @@ struct ReplaceIfYieldWithConditionOrValue : public OpRewritePattern<IfOp> {
}
if (trueVal && !falseVal) {
if (!opResult.use_empty()) {
- opResult.replaceAllUsesWith(op.condition());
+ opResult.replaceAllUsesWith(op.getCondition());
changed = true;
}
}
@@ -1503,7 +1505,7 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
if (!prevIf)
return failure();
- if (nextIf.condition() != prevIf.condition())
+ if (nextIf.getCondition() != prevIf.getCondition())
return failure();
// Don't permit merging if a result of the first if is used
@@ -1516,15 +1518,15 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
llvm::append_range(mergedTypes, nextIf.getResultTypes());
IfOp combinedIf = rewriter.create<IfOp>(
- nextIf.getLoc(), mergedTypes, nextIf.condition(), /*hasElse=*/false);
- rewriter.eraseBlock(&combinedIf.thenRegion().back());
+ nextIf.getLoc(), mergedTypes, nextIf.getCondition(), /*hasElse=*/false);
+ rewriter.eraseBlock(&combinedIf.getThenRegion().back());
YieldOp thenYield = prevIf.thenYield();
YieldOp thenYield2 = nextIf.thenYield();
- combinedIf.thenRegion().getBlocks().splice(
- combinedIf.thenRegion().getBlocks().begin(),
- prevIf.thenRegion().getBlocks());
+ combinedIf.getThenRegion().getBlocks().splice(
+ combinedIf.getThenRegion().getBlocks().begin(),
+ prevIf.getThenRegion().getBlocks());
rewriter.mergeBlocks(nextIf.thenBlock(), combinedIf.thenBlock());
rewriter.setInsertionPointToEnd(combinedIf.thenBlock());
@@ -1535,15 +1537,15 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
rewriter.eraseOp(thenYield);
rewriter.eraseOp(thenYield2);
- combinedIf.elseRegion().getBlocks().splice(
- combinedIf.elseRegion().getBlocks().begin(),
- prevIf.elseRegion().getBlocks());
+ combinedIf.getElseRegion().getBlocks().splice(
+ combinedIf.getElseRegion().getBlocks().begin(),
+ prevIf.getElseRegion().getBlocks());
- if (!nextIf.elseRegion().empty()) {
- if (combinedIf.elseRegion().empty()) {
- combinedIf.elseRegion().getBlocks().splice(
- combinedIf.elseRegion().getBlocks().begin(),
- nextIf.elseRegion().getBlocks());
+ if (!nextIf.getElseRegion().empty()) {
+ if (combinedIf.getElseRegion().empty()) {
+ combinedIf.getElseRegion().getBlocks().splice(
+ combinedIf.getElseRegion().getBlocks().begin(),
+ nextIf.getElseRegion().getBlocks());
} else {
YieldOp elseYield = combinedIf.elseYield();
YieldOp elseYield2 = nextIf.elseYield();
@@ -1587,8 +1589,8 @@ struct RemoveEmptyElseBranch : public OpRewritePattern<IfOp> {
if (!elseBlock || !llvm::hasSingleElement(*elseBlock))
return failure();
auto newIfOp = rewriter.cloneWithoutRegions(ifOp);
- rewriter.inlineRegionBefore(ifOp.thenRegion(), newIfOp.thenRegion(),
- newIfOp.thenRegion().begin());
+ rewriter.inlineRegionBefore(ifOp.getThenRegion(), newIfOp.getThenRegion(),
+ newIfOp.getThenRegion().begin());
rewriter.eraseOp(ifOp);
return success();
}
@@ -1604,10 +1606,10 @@ void IfOp::getCanonicalizationPatterns(RewritePatternSet &results,
RemoveEmptyElseBranch>(context);
}
-Block *IfOp::thenBlock() { return &thenRegion().back(); }
+Block *IfOp::thenBlock() { return &getThenRegion().back(); }
YieldOp IfOp::thenYield() { return cast<YieldOp>(&thenBlock()->back()); }
Block *IfOp::elseBlock() {
- Region &r = elseRegion();
+ Region &r = getElseRegion();
if (r.empty())
return nullptr;
return &r.back();
@@ -1674,7 +1676,7 @@ static LogicalResult verify(ParallelOp op) {
// Check that there is at least one value in lowerBound, upperBound and step.
// It is sufficient to test only step, because it is ensured already that the
// number of elements in lowerBound, upperBound and step are the same.
- Operation::operand_range stepValues = op.step();
+ Operation::operand_range stepValues = op.getStep();
if (stepValues.empty())
return op.emitOpError(
"needs at least one tuple element for lowerBound, upperBound and step");
@@ -1706,9 +1708,9 @@ static LogicalResult verify(ParallelOp op) {
// Check that the number of results is the same as the number of ReduceOps.
SmallVector<ReduceOp, 4> reductions(body->getOps<ReduceOp>());
- auto resultsSize = op.results().size();
+ auto resultsSize = op.getResults().size();
auto reductionsSize = reductions.size();
- auto initValsSize = op.initVals().size();
+ auto initValsSize = op.getInitVals().size();
if (resultsSize != reductionsSize)
return op.emitOpError()
<< "expects number of results: " << resultsSize
@@ -1719,10 +1721,10 @@ static LogicalResult verify(ParallelOp op) {
<< " to be the same as number of initial values: " << initValsSize;
// Check that the types of the results and reductions are the same.
- for (auto resultAndReduce : llvm::zip(op.results(), reductions)) {
+ for (auto resultAndReduce : llvm::zip(op.getResults(), reductions)) {
auto resultType = std::get<0>(resultAndReduce).getType();
auto reduceOp = std::get<1>(resultAndReduce);
- auto reduceType = reduceOp.operand().getType();
+ auto reduceType = reduceOp.getOperand().getType();
if (resultType != reduceType)
return reduceOp.emitOpError()
<< "expects type of reduce: " << reduceType
@@ -1803,20 +1805,20 @@ static ParseResult parseParallelOp(OpAsmParser &parser,
}
static void print(OpAsmPrinter &p, ParallelOp op) {
- p << " (" << op.getBody()->getArguments() << ") = (" << op.lowerBound()
- << ") to (" << op.upperBound() << ") step (" << op.step() << ")";
- if (!op.initVals().empty())
- p << " init (" << op.initVals() << ")";
+ p << " (" << op.getBody()->getArguments() << ") = (" << op.getLowerBound()
+ << ") to (" << op.getUpperBound() << ") step (" << op.getStep() << ")";
+ if (!op.getInitVals().empty())
+ p << " init (" << op.getInitVals() << ")";
p.printOptionalArrowTypeList(op.getResultTypes());
- p.printRegion(op.region(), /*printEntryBlockArgs=*/false);
+ p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false);
p.printOptionalAttrDict(
op->getAttrs(), /*elidedAttrs=*/ParallelOp::getOperandSegmentSizeAttr());
}
-Region &ParallelOp::getLoopBody() { return region(); }
+Region &ParallelOp::getLoopBody() { return getRegion(); }
bool ParallelOp::isDefinedOutsideOfLoop(Value value) {
- return !region().isAncestor(value.getParentRegion());
+ return !getRegion().isAncestor(value.getParentRegion());
}
LogicalResult ParallelOp::moveOutOfLoop(ArrayRef<Operation *> ops) {
@@ -1846,11 +1848,11 @@ struct CollapseSingleIterationLoops : public OpRewritePattern<ParallelOp> {
SmallVector<Value, 2> newLowerBounds;
SmallVector<Value, 2> newUpperBounds;
SmallVector<Value, 2> newSteps;
- newLowerBounds.reserve(op.lowerBound().size());
- newUpperBounds.reserve(op.upperBound().size());
- newSteps.reserve(op.step().size());
- for (auto dim : llvm::zip(op.lowerBound(), op.upperBound(), op.step(),
- op.getInductionVars())) {
+ newLowerBounds.reserve(op.getLowerBound().size());
+ newUpperBounds.reserve(op.getUpperBound().size());
+ newSteps.reserve(op.getStep().size());
+ for (auto dim : llvm::zip(op.getLowerBound(), op.getUpperBound(),
+ op.getStep(), op.getInductionVars())) {
Value lowerBound, upperBound, step, iv;
std::tie(lowerBound, upperBound, step, iv) = dim;
// Collect the statically known loop bounds.
@@ -1874,30 +1876,30 @@ struct CollapseSingleIterationLoops : public OpRewritePattern<ParallelOp> {
}
}
// Exit if none of the loop dimensions perform a single iteration.
- if (newLowerBounds.size() == op.lowerBound().size())
+ if (newLowerBounds.size() == op.getLowerBound().size())
return failure();
if (newLowerBounds.empty()) {
// All of the loop dimensions perform a single iteration. Inline
// loop body and nested ReduceOp's
SmallVector<Value> results;
- results.reserve(op.initVals().size());
+ results.reserve(op.getInitVals().size());
for (auto &bodyOp : op.getLoopBody().front().without_terminator()) {
auto reduce = dyn_cast<ReduceOp>(bodyOp);
if (!reduce) {
rewriter.clone(bodyOp, mapping);
continue;
}
- Block &reduceBlock = reduce.reductionOperator().front();
+ Block &reduceBlock = reduce.getReductionOperator().front();
auto initValIndex = results.size();
- mapping.map(reduceBlock.getArgument(0), op.initVals()[initValIndex]);
+ mapping.map(reduceBlock.getArgument(0), op.getInitVals()[initValIndex]);
mapping.map(reduceBlock.getArgument(1),
- mapping.lookupOrDefault(reduce.operand()));
+ mapping.lookupOrDefault(reduce.getOperand()));
for (auto &reduceBodyOp : reduceBlock.without_terminator())
rewriter.clone(reduceBodyOp, mapping);
auto result = mapping.lookupOrDefault(
- cast<ReduceReturnOp>(reduceBlock.getTerminator()).result());
+ cast<ReduceReturnOp>(reduceBlock.getTerminator()).getResult());
results.push_back(result);
}
rewriter.replaceOp(op, results);
@@ -1906,11 +1908,11 @@ struct CollapseSingleIterationLoops : public OpRewritePattern<ParallelOp> {
// Replace the parallel loop by lower-dimensional parallel loop.
auto newOp =
rewriter.create<ParallelOp>(op.getLoc(), newLowerBounds, newUpperBounds,
- newSteps, op.initVals(), nullptr);
+ newSteps, op.getInitVals(), nullptr);
// Clone the loop body and remap the block arguments of the collapsed loops
// (inlining does not support a cancellable block argument mapping).
- rewriter.cloneRegionBefore(op.region(), newOp.region(),
- newOp.region().begin(), mapping);
+ rewriter.cloneRegionBefore(op.getRegion(), newOp.getRegion(),
+ newOp.getRegion().begin(), mapping);
rewriter.replaceOp(op, newOp.getResults());
return success();
}
@@ -1923,9 +1925,9 @@ struct RemoveEmptyParallelLoops : public OpRewritePattern<ParallelOp> {
LogicalResult matchAndRewrite(ParallelOp op,
PatternRewriter &rewriter) const override {
- for (auto dim : llvm::zip(op.lowerBound(), op.upperBound())) {
+ for (auto dim : llvm::zip(op.getLowerBound(), op.getUpperBound())) {
if (std::get<0>(dim) == std::get<1>(dim)) {
- rewriter.replaceOp(op, op.initVals());
+ rewriter.replaceOp(op, op.getInitVals());
return success();
}
}
@@ -1951,12 +1953,13 @@ struct MergeNestedParallelLoops : public OpRewritePattern<ParallelOp> {
};
for (auto val : outerBody.getArguments())
- if (hasVal(innerOp.lowerBound(), val) ||
- hasVal(innerOp.upperBound(), val) || hasVal(innerOp.step(), val))
+ if (hasVal(innerOp.getLowerBound(), val) ||
+ hasVal(innerOp.getUpperBound(), val) ||
+ hasVal(innerOp.getStep(), val))
return failure();
// Reductions are not supported yet.
- if (!op.initVals().empty() || !innerOp.initVals().empty())
+ if (!op.getInitVals().empty() || !innerOp.getInitVals().empty())
return failure();
auto bodyBuilder = [&](OpBuilder &builder, Location /*loc*/,
@@ -1981,9 +1984,11 @@ struct MergeNestedParallelLoops : public OpRewritePattern<ParallelOp> {
return ret;
};
- auto newLowerBounds = concatValues(op.lowerBound(), innerOp.lowerBound());
- auto newUpperBounds = concatValues(op.upperBound(), innerOp.upperBound());
- auto newSteps = concatValues(op.step(), innerOp.step());
+ auto newLowerBounds =
+ concatValues(op.getLowerBound(), innerOp.getLowerBound());
+ auto newUpperBounds =
+ concatValues(op.getUpperBound(), innerOp.getUpperBound());
+ auto newSteps = concatValues(op.getStep(), innerOp.getStep());
rewriter.replaceOpWithNewOp<ParallelOp>(op, newLowerBounds, newUpperBounds,
newSteps, llvm::None, bodyBuilder);
@@ -2019,8 +2024,8 @@ void ReduceOp::build(
static LogicalResult verify(ReduceOp op) {
// The region of a ReduceOp has two arguments of the same type as its operand.
- auto type = op.operand().getType();
- Block &block = op.reductionOperator().front();
+ auto type = op.getOperand().getType();
+ Block &block = op.getReductionOperator().front();
if (block.empty())
return op.emitOpError("the block inside reduce should not be empty");
if (block.getNumArguments() != 2 ||
@@ -2060,9 +2065,9 @@ static ParseResult parseReduceOp(OpAsmParser &parser, OperationState &result) {
}
static void print(OpAsmPrinter &p, ReduceOp op) {
- p << "(" << op.operand() << ") ";
- p << " : " << op.operand().getType();
- p.printRegion(op.reductionOperator());
+ p << "(" << op.getOperand() << ") ";
+ p << " : " << op.getOperand().getType();
+ p.printRegion(op.getReductionOperator());
}
//===----------------------------------------------------------------------===//
@@ -2073,8 +2078,8 @@ static LogicalResult verify(ReduceReturnOp op) {
// The type of the return value should be the same type as the type of the
// operand of the enclosing ReduceOp.
auto reduceOp = cast<ReduceOp>(op->getParentOp());
- Type reduceType = reduceOp.operand().getType();
- if (reduceType != op.result().getType())
+ Type reduceType = reduceOp.getOperand().getType();
+ if (reduceType != op.getResult().getType())
return op.emitOpError() << "needs to have type " << reduceType
<< " (the type of the enclosing ReduceOp)";
return success();
@@ -2088,15 +2093,15 @@ OperandRange WhileOp::getSuccessorEntryOperands(unsigned index) {
assert(index == 0 &&
"WhileOp is expected to branch only to the first region");
- return inits();
+ return getInits();
}
ConditionOp WhileOp::getConditionOp() {
- return cast<ConditionOp>(before().front().getTerminator());
+ return cast<ConditionOp>(getBefore().front().getTerminator());
}
Block::BlockArgListType WhileOp::getAfterArguments() {
- return after().front().getArguments();
+ return getAfter().front().getArguments();
}
void WhileOp::getSuccessorRegions(Optional<unsigned> index,
@@ -2105,18 +2110,18 @@ void WhileOp::getSuccessorRegions(Optional<unsigned> index,
(void)operands;
if (!index.hasValue()) {
- regions.emplace_back(&before(), before().getArguments());
+ regions.emplace_back(&getBefore(), getBefore().getArguments());
return;
}
assert(*index < 2 && "there are only two regions in a WhileOp");
if (*index == 0) {
- regions.emplace_back(&after(), after().getArguments());
+ regions.emplace_back(&getAfter(), getAfter().getArguments());
regions.emplace_back(getResults());
return;
}
- regions.emplace_back(&before(), before().getArguments());
+ regions.emplace_back(&getBefore(), getBefore().getArguments());
}
/// Parses a `while` op.
@@ -2164,13 +2169,13 @@ static ParseResult parseWhileOp(OpAsmParser &parser, OperationState &result) {
/// Prints a `while` op.
static void print(OpAsmPrinter &p, scf::WhileOp op) {
- printInitializationList(p, op.before().front().getArguments(), op.inits(),
- " ");
+ printInitializationList(p, op.getBefore().front().getArguments(),
+ op.getInits(), " ");
p << " : ";
- p.printFunctionalType(op.inits().getTypes(), op.results().getTypes());
- p.printRegion(op.before(), /*printEntryBlockArgs=*/false);
+ p.printFunctionalType(op.getInits().getTypes(), op.getResults().getTypes());
+ p.printRegion(op.getBefore(), /*printEntryBlockArgs=*/false);
p << " do";
- p.printRegion(op.after());
+ p.printRegion(op.getAfter());
p.printOptionalAttrDictWithKeyword(op->getAttrs());
}
@@ -2216,13 +2221,13 @@ static LogicalResult verify(scf::WhileOp op) {
return failure();
auto beforeTerminator = verifyAndGetTerminator<scf::ConditionOp>(
- op, op.before(),
+ op, op.getBefore(),
"expects the 'before' region to terminate with 'scf.condition'");
if (!beforeTerminator)
return failure();
auto afterTerminator = verifyAndGetTerminator<scf::YieldOp>(
- op, op.after(),
+ op, op.getAfter(),
"expects the 'after' region to terminate with 'scf.yield'");
return success(afterTerminator != nullptr);
}
@@ -2260,12 +2265,12 @@ struct WhileConditionTruth : public OpRewritePattern<WhileOp> {
bool replaced = false;
for (auto yieldedAndBlockArgs :
- llvm::zip(term.args(), op.getAfterArguments())) {
- if (std::get<0>(yieldedAndBlockArgs) == term.condition()) {
+ llvm::zip(term.getArgs(), op.getAfterArguments())) {
+ if (std::get<0>(yieldedAndBlockArgs) == term.getCondition()) {
if (!std::get<1>(yieldedAndBlockArgs).use_empty()) {
if (!constantTrue)
constantTrue = rewriter.create<arith::ConstantOp>(
- op.getLoc(), term.condition().getType(),
+ op.getLoc(), term.getCondition().getType(),
rewriter.getBoolAttr(true));
std::get<1>(yieldedAndBlockArgs).replaceAllUsesWith(constantTrue);
@@ -2310,7 +2315,7 @@ struct WhileUnusedResult : public OpRewritePattern<WhileOp> {
PatternRewriter &rewriter) const override {
auto term = op.getConditionOp();
auto afterArgs = op.getAfterArguments();
- auto termArgs = term.args();
+ auto termArgs = term.getArgs();
// Collect results mapping, new terminator args and new result types.
SmallVector<unsigned> newResultsIndices;
@@ -2338,15 +2343,15 @@ struct WhileUnusedResult : public OpRewritePattern<WhileOp> {
{
OpBuilder::InsertionGuard g(rewriter);
rewriter.setInsertionPoint(term);
- rewriter.replaceOpWithNewOp<ConditionOp>(term, term.condition(),
+ rewriter.replaceOpWithNewOp<ConditionOp>(term, term.getCondition(),
newTermArgs);
}
auto newWhile =
- rewriter.create<WhileOp>(op.getLoc(), newResultTypes, op.inits());
+ rewriter.create<WhileOp>(op.getLoc(), newResultTypes, op.getInits());
Block &newAfterBlock = *rewriter.createBlock(
- &newWhile.after(), /*insertPt*/ {}, newResultTypes);
+ &newWhile.getAfter(), /*insertPt*/ {}, newResultTypes);
// Build new results list and new after block args (unused entries will be
// null).
@@ -2357,10 +2362,10 @@ struct WhileUnusedResult : public OpRewritePattern<WhileOp> {
newAfterBlockArgs[it.value()] = newAfterBlock.getArgument(it.index());
}
- rewriter.inlineRegionBefore(op.before(), newWhile.before(),
- newWhile.before().begin());
+ rewriter.inlineRegionBefore(op.getBefore(), newWhile.getBefore(),
+ newWhile.getBefore().begin());
- Block &afterBlock = op.after().front();
+ Block &afterBlock = op.getAfter().front();
rewriter.mergeBlocks(&afterBlock, &newAfterBlock, newAfterBlockArgs);
rewriter.replaceOp(op, newResults);
diff --git a/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp b/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
index 44e3b514825be..a3f3070440522 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
@@ -35,24 +35,24 @@ struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
// variable is placed first, followed by the forOp.iterArgs.
SmallVector<Type, 8> lcvTypes;
lcvTypes.push_back(forOp.getInductionVar().getType());
- llvm::transform(forOp.initArgs(), std::back_inserter(lcvTypes),
+ llvm::transform(forOp.getInitArgs(), std::back_inserter(lcvTypes),
[&](auto v) { return v.getType(); });
// Build scf.WhileOp
SmallVector<Value> initArgs;
- initArgs.push_back(forOp.lowerBound());
- llvm::append_range(initArgs, forOp.initArgs());
+ initArgs.push_back(forOp.getLowerBound());
+ llvm::append_range(initArgs, forOp.getInitArgs());
auto whileOp = rewriter.create<WhileOp>(forOp.getLoc(), lcvTypes, initArgs,
forOp->getAttrs());
// 'before' region contains the loop condition and forwarding of iteration
// arguments to the 'after' region.
auto *beforeBlock = rewriter.createBlock(
- &whileOp.before(), whileOp.before().begin(), lcvTypes, {});
- rewriter.setInsertionPointToStart(&whileOp.before().front());
+ &whileOp.getBefore(), whileOp.getBefore().begin(), lcvTypes, {});
+ rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
auto cmpOp = rewriter.create<arith::CmpIOp>(
whileOp.getLoc(), arith::CmpIPredicate::slt,
- beforeBlock->getArgument(0), forOp.upperBound());
+ beforeBlock->getArgument(0), forOp.getUpperBound());
rewriter.create<scf::ConditionOp>(whileOp.getLoc(), cmpOp.getResult(),
beforeBlock->getArguments());
@@ -60,12 +60,12 @@ struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
// region. The return type of the execRegionOp does not contain the
// iv - yields in the source for-loop contain only iterArgs.
auto *afterBlock = rewriter.createBlock(
- &whileOp.after(), whileOp.after().begin(), lcvTypes, {});
+ &whileOp.getAfter(), whileOp.getAfter().begin(), lcvTypes, {});
// Add induction variable incrementation
rewriter.setInsertionPointToEnd(afterBlock);
auto ivIncOp = rewriter.create<arith::AddIOp>(
- whileOp.getLoc(), afterBlock->getArgument(0), forOp.step());
+ whileOp.getLoc(), afterBlock->getArgument(0), forOp.getStep());
// Rewrite uses of the for-loop block arguments to the new while-loop
// "after" arguments
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp
index 7c903b9c0843d..1c133979b22c1 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopCanonicalization.cpp
@@ -32,9 +32,9 @@ using namespace mlir::scf;
/// Note: This function handles only simple cases. Expand as needed.
static bool isShapePreserving(ForOp forOp, int64_t arg) {
auto yieldOp = cast<YieldOp>(forOp.getBody()->getTerminator());
- assert(arg < static_cast<int64_t>(yieldOp.results().size()) &&
+ assert(arg < static_cast<int64_t>(yieldOp.getResults().size()) &&
"arg is out of bounds");
- Value value = yieldOp.results()[arg];
+ Value value = yieldOp.getResults()[arg];
while (value) {
if (value == forOp.getRegionIterArgs()[arg])
return true;
@@ -155,17 +155,17 @@ struct AffineOpSCFCanonicalizationPattern : public OpRewritePattern<OpTy> {
PatternRewriter &rewriter) const override {
auto loopMatcher = [](Value iv, Value &lb, Value &ub, Value &step) {
if (scf::ForOp forOp = scf::getForInductionVarOwner(iv)) {
- lb = forOp.lowerBound();
- ub = forOp.upperBound();
- step = forOp.step();
+ lb = forOp.getLowerBound();
+ ub = forOp.getUpperBound();
+ step = forOp.getStep();
return success();
}
if (scf::ParallelOp parOp = scf::getParallelForInductionVarOwner(iv)) {
for (unsigned idx = 0; idx < parOp.getNumLoops(); ++idx) {
if (parOp.getInductionVars()[idx] == iv) {
- lb = parOp.lowerBound()[idx];
- ub = parOp.upperBound()[idx];
- step = parOp.step()[idx];
+ lb = parOp.getLowerBound()[idx];
+ ub = parOp.getUpperBound()[idx];
+ step = parOp.getStep()[idx];
return success();
}
}
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
index ba44b4a702a2c..321d953c17edf 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
@@ -82,10 +82,10 @@ bool LoopPipelinerInternal::initializeLoopInfo(
ForOp op, const PipeliningOption &options) {
forOp = op;
auto upperBoundCst =
- forOp.upperBound().getDefiningOp<arith::ConstantIndexOp>();
+ forOp.getUpperBound().getDefiningOp<arith::ConstantIndexOp>();
auto lowerBoundCst =
- forOp.lowerBound().getDefiningOp<arith::ConstantIndexOp>();
- auto stepCst = forOp.step().getDefiningOp<arith::ConstantIndexOp>();
+ forOp.getLowerBound().getDefiningOp<arith::ConstantIndexOp>();
+ auto stepCst = forOp.getStep().getDefiningOp<arith::ConstantIndexOp>();
if (!upperBoundCst || !lowerBoundCst || !stepCst)
return false;
ub = upperBoundCst.value();
@@ -226,8 +226,9 @@ scf::ForOp LoopPipelinerInternal::createKernelLoop(
// iteration we change the upper bound to remove those iterations.
Value newUb = rewriter.create<arith::ConstantIndexOp>(forOp.getLoc(),
ub - maxStage * step);
- auto newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.lowerBound(), newUb, forOp.step(), newLoopArg);
+ auto newForOp =
+ rewriter.create<scf::ForOp>(forOp.getLoc(), forOp.getLowerBound(), newUb,
+ forOp.getStep(), newLoopArg);
return newForOp;
}
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp
index d65b78ee6a9a7..bca5abdd9bcec 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopRangeFolding.cpp
@@ -54,11 +54,11 @@ void ForLoopRangeFolding::runOnOperation() {
OpBuilder b(op);
BlockAndValueMapping lbMap;
- lbMap.map(indVar, op.lowerBound());
+ lbMap.map(indVar, op.getLowerBound());
BlockAndValueMapping ubMap;
- ubMap.map(indVar, op.upperBound());
+ ubMap.map(indVar, op.getUpperBound());
BlockAndValueMapping stepMap;
- stepMap.map(indVar, op.step());
+ stepMap.map(indVar, op.getStep());
if (isa<arith::AddIOp>(user)) {
Operation *lbFold = b.clone(*user, lbMap);
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
index 6461ea9d5e6ce..da15c49c9107b 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
@@ -37,8 +37,8 @@ using scf::ParallelOp;
/// that version can be fully unrolled and vectorized.
static void specializeParallelLoopForUnrolling(ParallelOp op) {
SmallVector<int64_t, 2> constantIndices;
- constantIndices.reserve(op.upperBound().size());
- for (auto bound : op.upperBound()) {
+ constantIndices.reserve(op.getUpperBound().size());
+ for (auto bound : op.getUpperBound()) {
auto minOp = bound.getDefiningOp<AffineMinOp>();
if (!minOp)
return;
@@ -55,7 +55,7 @@ static void specializeParallelLoopForUnrolling(ParallelOp op) {
OpBuilder b(op);
BlockAndValueMapping map;
Value cond;
- for (auto bound : llvm::zip(op.upperBound(), constantIndices)) {
+ for (auto bound : llvm::zip(op.getUpperBound(), constantIndices)) {
Value constant =
b.create<arith::ConstantIndexOp>(op.getLoc(), std::get<1>(bound));
Value cmp = b.create<arith::CmpIOp>(op.getLoc(), arith::CmpIPredicate::eq,
@@ -74,7 +74,7 @@ static void specializeParallelLoopForUnrolling(ParallelOp op) {
/// beneficial if the loop will almost always have the constant bound and that
/// version can be fully unrolled and vectorized.
static void specializeForLoopForUnrolling(ForOp op) {
- auto bound = op.upperBound();
+ auto bound = op.getUpperBound();
auto minOp = bound.getDefiningOp<AffineMinOp>();
if (!minOp)
return;
@@ -112,9 +112,9 @@ static void specializeForLoopForUnrolling(ForOp op) {
static LogicalResult peelForLoop(RewriterBase &b, ForOp forOp,
ForOp &partialIteration, Value &splitBound) {
RewriterBase::InsertionGuard guard(b);
- auto lbInt = getConstantIntValue(forOp.lowerBound());
- auto ubInt = getConstantIntValue(forOp.upperBound());
- auto stepInt = getConstantIntValue(forOp.step());
+ auto lbInt = getConstantIntValue(forOp.getLowerBound());
+ auto ubInt = getConstantIntValue(forOp.getUpperBound());
+ auto stepInt = getConstantIntValue(forOp.getStep());
// No specialization necessary if step already divides upper bound evenly.
if (lbInt && ubInt && stepInt && (*ubInt - *lbInt) % *stepInt == 0)
@@ -129,20 +129,21 @@ static LogicalResult peelForLoop(RewriterBase &b, ForOp forOp,
// New upper bound: %ub - (%ub - %lb) mod %step
auto modMap = AffineMap::get(0, 3, {sym1 - ((sym1 - sym0) % sym2)});
b.setInsertionPoint(forOp);
- splitBound = b.createOrFold<AffineApplyOp>(
- loc, modMap,
- ValueRange{forOp.lowerBound(), forOp.upperBound(), forOp.step()});
+ splitBound = b.createOrFold<AffineApplyOp>(loc, modMap,
+ ValueRange{forOp.getLowerBound(),
+ forOp.getUpperBound(),
+ forOp.getStep()});
// Create ForOp for partial iteration.
b.setInsertionPointAfter(forOp);
partialIteration = cast<ForOp>(b.clone(*forOp.getOperation()));
- partialIteration.lowerBoundMutable().assign(splitBound);
+ partialIteration.getLowerBoundMutable().assign(splitBound);
forOp.replaceAllUsesWith(partialIteration->getResults());
- partialIteration.initArgsMutable().assign(forOp->getResults());
+ partialIteration.getInitArgsMutable().assign(forOp->getResults());
// Set new upper loop bound.
- b.updateRootInPlace(forOp,
- [&]() { forOp.upperBoundMutable().assign(splitBound); });
+ b.updateRootInPlace(
+ forOp, [&]() { forOp.getUpperBoundMutable().assign(splitBound); });
return success();
}
@@ -153,9 +154,9 @@ static void rewriteAffineOpAfterPeeling(RewriterBase &rewriter, ForOp forOp,
Value previousUb) {
Value mainIv = forOp.getInductionVar();
Value partialIv = partialIteration.getInductionVar();
- assert(forOp.step() == partialIteration.step() &&
+ assert(forOp.getStep() == partialIteration.getStep() &&
"expected same step in main and partial loop");
- Value step = forOp.step();
+ Value step = forOp.getStep();
forOp.walk([&](OpTy affineOp) {
AffineMap map = affineOp.getAffineMap();
@@ -175,7 +176,7 @@ static void rewriteAffineOpAfterPeeling(RewriterBase &rewriter, ForOp forOp,
LogicalResult mlir::scf::peelAndCanonicalizeForLoop(RewriterBase &rewriter,
ForOp forOp,
ForOp &partialIteration) {
- Value previousUb = forOp.upperBound();
+ Value previousUb = forOp.getUpperBound();
Value splitBound;
if (failed(peelForLoop(rewriter, forOp, partialIteration, splitBound)))
return failure();
diff --git a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
index 32c5abc2decf6..f4f87511603bc 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
@@ -41,9 +41,11 @@ static bool equalIterationSpaces(ParallelOp firstPloop,
// TODO: Extend this to support aliases and equal constants.
return std::equal(lhs.begin(), lhs.end(), rhs.begin());
};
- return matchOperands(firstPloop.lowerBound(), secondPloop.lowerBound()) &&
- matchOperands(firstPloop.upperBound(), secondPloop.upperBound()) &&
- matchOperands(firstPloop.step(), secondPloop.step());
+ return matchOperands(firstPloop.getLowerBound(),
+ secondPloop.getLowerBound()) &&
+ matchOperands(firstPloop.getUpperBound(),
+ secondPloop.getUpperBound()) &&
+ matchOperands(firstPloop.getStep(), secondPloop.getStep());
}
/// Checks if the parallel loops have mixed access to the same buffers. Returns
diff --git a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
index 45ff2a49b0878..998c73624ca75 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
@@ -56,8 +56,8 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
OpBuilder b(op);
auto zero = b.create<arith::ConstantIndexOp>(op.getLoc(), 0);
SmallVector<Value, 2> tileSizeConstants;
- tileSizeConstants.reserve(op.upperBound().size());
- for (size_t i = 0, end = op.upperBound().size(); i != end; ++i) {
+ tileSizeConstants.reserve(op.getUpperBound().size());
+ for (size_t i = 0, end = op.getUpperBound().size(); i != end; ++i) {
if (i < tileSizes.size())
tileSizeConstants.push_back(
b.create<arith::ConstantIndexOp>(op.getLoc(), tileSizes[i]));
@@ -69,13 +69,13 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
// Create the outer loop with adjusted steps.
SmallVector<Value, 2> newSteps;
- newSteps.reserve(op.step().size());
- for (auto step : llvm::zip(op.step(), tileSizeConstants)) {
+ newSteps.reserve(op.getStep().size());
+ for (auto step : llvm::zip(op.getStep(), tileSizeConstants)) {
newSteps.push_back(b.create<arith::MulIOp>(op.getLoc(), std::get<0>(step),
std::get<1>(step)));
}
- auto outerLoop = b.create<ParallelOp>(op.getLoc(), op.lowerBound(),
- op.upperBound(), newSteps);
+ auto outerLoop = b.create<ParallelOp>(op.getLoc(), op.getLowerBound(),
+ op.getUpperBound(), newSteps);
b.setInsertionPointToStart(outerLoop.getBody());
// Compute min(size, dim - offset) to avoid out-of-bounds accesses.
@@ -88,11 +88,12 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
// Create the inner loop with adjusted bounds.
SmallVector<Value, 2> newBounds;
- newBounds.reserve(op.upperBound().size());
+ newBounds.reserve(op.getUpperBound().size());
bool needInboundCheck = false;
- for (auto dim : llvm::zip(outerLoop.lowerBound(), outerLoop.upperBound(),
- outerLoop.step(), outerLoop.getInductionVars(),
- op.step(), tileSizeConstants)) {
+ for (auto dim :
+ llvm::zip(outerLoop.getLowerBound(), outerLoop.getUpperBound(),
+ outerLoop.getStep(), outerLoop.getInductionVars(),
+ op.getStep(), tileSizeConstants)) {
Value lowerBound, upperBound, newStep, iv, step, tileSizeConstant;
std::tie(lowerBound, upperBound, newStep, iv, step, tileSizeConstant) = dim;
// Collect the statically known loop bounds
@@ -132,7 +133,7 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
}
auto innerLoop = b.create<ParallelOp>(
op.getLoc(), SmallVector<Value, 2>(newBounds.size(), zero), newBounds,
- op.step());
+ op.getStep());
if (noMinMaxBounds && needInboundCheck) {
b.setInsertionPointToStart(innerLoop.getBody());
@@ -140,8 +141,8 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
Value inbound =
b.create<arith::ConstantIntOp>(op.getLoc(), 1, b.getIntegerType(1));
for (auto dim :
- llvm::zip(outerLoop.upperBound(), outerLoop.getInductionVars(),
- innerLoop.getInductionVars(), innerLoop.step())) {
+ llvm::zip(outerLoop.getUpperBound(), outerLoop.getInductionVars(),
+ innerLoop.getInductionVars(), innerLoop.getStep())) {
Value outerUpperBound, outerIV, innerIV, innerStep;
std::tie(outerUpperBound, outerIV, innerIV, innerStep) = dim;
// %in_bound = %in_bound &&
@@ -156,8 +157,8 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
auto ifInbound = b.create<IfOp>(op.getLoc(),
/*resultTypes*/ ArrayRef<Type>{}, inbound,
/*hasElseRegion*/ false);
- ifInbound.thenRegion().takeBody(op.region());
- Block &thenBlock = ifInbound.thenRegion().front();
+ ifInbound.getThenRegion().takeBody(op.getRegion());
+ Block &thenBlock = ifInbound.getThenRegion().front();
b.setInsertionPointToStart(innerLoop.getBody());
for (auto ivs : llvm::enumerate(llvm::zip(innerLoop.getInductionVars(),
outerLoop.getInductionVars()))) {
@@ -169,7 +170,7 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
thenBlock.eraseArguments(llvm::to_vector<4>(
llvm::seq((unsigned)0, thenBlock.getNumArguments())));
} else {
- innerLoop.region().takeBody(op.region());
+ innerLoop.getRegion().takeBody(op.getRegion());
b.setInsertionPointToStart(innerLoop.getBody());
for (auto ivs : llvm::zip(innerLoop.getInductionVars(),
outerLoop.getInductionVars())) {
diff --git a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
index b84a6cbeb1196..3a963c70e1148 100644
--- a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
@@ -102,10 +102,10 @@ class ConvertIfOpTypes : public OpConversionPattern<IfOp> {
// See comments in the ForOp pattern for why we clone without regions and
// then inline.
IfOp newOp = cast<IfOp>(rewriter.cloneWithoutRegions(*op.getOperation()));
- rewriter.inlineRegionBefore(op.thenRegion(), newOp.thenRegion(),
- newOp.thenRegion().end());
- rewriter.inlineRegionBefore(op.elseRegion(), newOp.elseRegion(),
- newOp.elseRegion().end());
+ rewriter.inlineRegionBefore(op.getThenRegion(), newOp.getThenRegion(),
+ newOp.getThenRegion().end());
+ rewriter.inlineRegionBefore(op.getElseRegion(), newOp.getElseRegion(),
+ newOp.getElseRegion().end());
// Update the operands and types.
newOp->setOperands(adaptor.getOperands());
diff --git a/mlir/lib/Dialect/SCF/Transforms/Utils.cpp b/mlir/lib/Dialect/SCF/Transforms/Utils.cpp
index 00fa22be754fb..c8e557cbe5afa 100644
--- a/mlir/lib/Dialect/SCF/Transforms/Utils.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/Utils.cpp
@@ -35,8 +35,8 @@ scf::ForOp mlir::cloneWithNewYields(OpBuilder &b, scf::ForOp loop,
auto operands = llvm::to_vector<4>(loop.getIterOperands());
operands.append(newIterOperands.begin(), newIterOperands.end());
scf::ForOp newLoop =
- b.create<scf::ForOp>(loop.getLoc(), loop.lowerBound(), loop.upperBound(),
- loop.step(), operands);
+ b.create<scf::ForOp>(loop.getLoc(), loop.getLowerBound(),
+ loop.getUpperBound(), loop.getStep(), operands);
auto &loopBody = *loop.getBody();
auto &newLoopBody = *newLoop.getBody();
@@ -118,10 +118,10 @@ void mlir::outlineIfOp(OpBuilder &b, scf::IfOp ifOp, FuncOp *thenFn,
return outlinedFunc;
};
- if (thenFn && !ifOp.thenRegion().empty())
- *thenFn = outline(ifOp.thenRegion(), thenFnName);
- if (elseFn && !ifOp.elseRegion().empty())
- *elseFn = outline(ifOp.elseRegion(), elseFnName);
+ if (thenFn && !ifOp.getThenRegion().empty())
+ *thenFn = outline(ifOp.getThenRegion(), thenFnName);
+ if (elseFn && !ifOp.getElseRegion().empty())
+ *elseFn = outline(ifOp.getElseRegion(), elseFnName);
}
bool mlir::getInnermostParallelLoops(Operation *rootOp,
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
index 92a1c49213c52..047142b06320a 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp
@@ -365,7 +365,7 @@ static Value genIndexAndValueForDense(ConversionPatternRewriter &rewriter,
Value val = rewriter.create<tensor::ExtractOp>(loc, tensor, ivs);
Value cond = genIsNonzero(rewriter, loc, val);
scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, cond, /*else*/ false);
- rewriter.setInsertionPointToStart(&ifOp.thenRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
unsigned i = 0;
for (auto iv : ivs) {
Value idx = constantIndex(rewriter, loc, i++);
@@ -670,11 +670,11 @@ class SparseTensorConvertConverter : public OpConversionPattern<ConvertOp> {
SmallVector<Value> noArgs;
SmallVector<Type> noTypes;
auto whileOp = rewriter.create<scf::WhileOp>(loc, noTypes, noArgs);
- Block *before = rewriter.createBlock(&whileOp.before(), {}, noTypes);
+ Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, noTypes);
rewriter.setInsertionPointToEnd(before);
Value cond = genGetNextCall(rewriter, op, iter, ind, elemPtr);
rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
- Block *after = rewriter.createBlock(&whileOp.after(), {}, noTypes);
+ Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, noTypes);
rewriter.setInsertionPointToStart(after);
insertScalarIntoDenseTensor(rewriter, loc, elemPtr, dst, rank, ind);
rewriter.create<scf::YieldOp>(loc);
diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
index ac01d5dae1c59..6568633e477d5 100644
--- a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
+++ b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp
@@ -761,7 +761,7 @@ static void genInsertionStore(CodeGen &codegen, PatternRewriter &rewriter,
scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, rewriter.getIndexType(),
cond, /*else=*/true);
// True branch.
- rewriter.setInsertionPointToStart(&ifOp.thenRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
rewriter.create<memref::StoreOp>(loc, tval, codegen.expFilled, index);
rewriter.create<memref::StoreOp>(loc, index, codegen.expAdded,
codegen.expCount);
@@ -769,7 +769,7 @@ static void genInsertionStore(CodeGen &codegen, PatternRewriter &rewriter,
Value add = rewriter.create<arith::AddIOp>(loc, codegen.expCount, one);
rewriter.create<scf::YieldOp>(loc, add);
// False branch.
- rewriter.setInsertionPointToStart(&ifOp.elseRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
rewriter.create<scf::YieldOp>(loc, codegen.expCount);
rewriter.setInsertionPointAfter(ifOp);
// Value assignment.
@@ -1226,12 +1226,12 @@ static Operation *genWhile(Merger &merger, CodeGen &codegen,
assert(types.size() == operands.size());
Location loc = op.getLoc();
scf::WhileOp whileOp = rewriter.create<scf::WhileOp>(loc, types, operands);
- Block *before = rewriter.createBlock(&whileOp.before(), {}, types);
- Block *after = rewriter.createBlock(&whileOp.after(), {}, types);
+ Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, types);
+ Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, types);
// Build the "before" region, which effectively consists
// of a conjunction of "i < upper" tests on all induction.
- rewriter.setInsertionPointToStart(&whileOp.before().front());
+ rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
Value cond;
unsigned o = 0;
for (unsigned b = 0, be = indices.size(); b < be; b++) {
@@ -1254,7 +1254,7 @@ static Operation *genWhile(Merger &merger, CodeGen &codegen,
codegen.loops[idx] = after->getArgument(o++);
assert(o == operands.size());
rewriter.create<scf::ConditionOp>(loc, cond, before->getArguments());
- rewriter.setInsertionPointToStart(&whileOp.after().front());
+ rewriter.setInsertionPointToStart(&whileOp.getAfter().front());
return whileOp;
}
@@ -1365,7 +1365,7 @@ static void genWhileInduction(Merger &merger, CodeGen &codegen,
rewriter.setInsertionPointAfter(ifOp);
}
}
- rewriter.setInsertionPointToEnd(&whileOp.after().front());
+ rewriter.setInsertionPointToEnd(&whileOp.getAfter().front());
// Finalize the induction. Note that the induction could be performed
// in the individual if-branches to avoid re-evaluating the conditions.
// However, that would result in a rather elaborate forest of yield
@@ -1455,7 +1455,7 @@ static scf::IfOp genIf(Merger &merger, CodeGen &codegen,
if (codegen.expValues)
types.push_back(rewriter.getIndexType());
scf::IfOp ifOp = rewriter.create<scf::IfOp>(loc, types, cond, /*else=*/true);
- rewriter.setInsertionPointToStart(&ifOp.thenRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
return ifOp;
}
@@ -1474,7 +1474,7 @@ static void endIf(Merger &merger, CodeGen &codegen, PatternRewriter &rewriter,
}
if (!operands.empty())
rewriter.create<scf::YieldOp>(op.getLoc(), operands);
- rewriter.setInsertionPointToStart(&ifOp.elseRegion().front());
+ rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Target/Cpp/TranslateToCpp.cpp b/mlir/lib/Target/Cpp/TranslateToCpp.cpp
index 90f4f3080ad23..bf2a2e8461465 100644
--- a/mlir/lib/Target/Cpp/TranslateToCpp.cpp
+++ b/mlir/lib/Target/Cpp/TranslateToCpp.cpp
@@ -415,19 +415,19 @@ static LogicalResult printOperation(CppEmitter &emitter, scf::ForOp forOp) {
os << " ";
os << emitter.getOrCreateName(forOp.getInductionVar());
os << " = ";
- os << emitter.getOrCreateName(forOp.lowerBound());
+ os << emitter.getOrCreateName(forOp.getLowerBound());
os << "; ";
os << emitter.getOrCreateName(forOp.getInductionVar());
os << " < ";
- os << emitter.getOrCreateName(forOp.upperBound());
+ os << emitter.getOrCreateName(forOp.getUpperBound());
os << "; ";
os << emitter.getOrCreateName(forOp.getInductionVar());
os << " += ";
- os << emitter.getOrCreateName(forOp.step());
+ os << emitter.getOrCreateName(forOp.getStep());
os << ") {\n";
os.indent();
- Region &forRegion = forOp.region();
+ Region &forRegion = forOp.getRegion();
auto regionOps = forRegion.getOps();
// We skip the trailing yield op because this updates the result variables
@@ -479,7 +479,7 @@ static LogicalResult printOperation(CppEmitter &emitter, scf::IfOp ifOp) {
os << ") {\n";
os.indent();
- Region &thenRegion = ifOp.thenRegion();
+ Region &thenRegion = ifOp.getThenRegion();
for (Operation &op : thenRegion.getOps()) {
// Note: This prints a superfluous semicolon if the terminating yield op has
// zero results.
@@ -489,7 +489,7 @@ static LogicalResult printOperation(CppEmitter &emitter, scf::IfOp ifOp) {
os.unindent() << "}";
- Region &elseRegion = ifOp.elseRegion();
+ Region &elseRegion = ifOp.getElseRegion();
if (!elseRegion.empty()) {
os << " else {\n";
os.indent();
diff --git a/mlir/lib/Transforms/LoopCoalescing.cpp b/mlir/lib/Transforms/LoopCoalescing.cpp
index f930c53ad69af..32a7e52e42bf8 100644
--- a/mlir/lib/Transforms/LoopCoalescing.cpp
+++ b/mlir/lib/Transforms/LoopCoalescing.cpp
@@ -43,7 +43,8 @@ struct LoopCoalescingPass : public LoopCoalescingBase<LoopCoalescingPass> {
for (unsigned i = 0, e = loops.size(); i < e; ++i) {
operandsDefinedAbove[i] = i;
for (unsigned j = 0; j < i; ++j) {
- if (areValuesDefinedAbove(loops[i].getOperands(), loops[j].region())) {
+ if (areValuesDefinedAbove(loops[i].getOperands(),
+ loops[j].getRegion())) {
operandsDefinedAbove[i] = j;
break;
}
diff --git a/mlir/lib/Transforms/Utils/LoopUtils.cpp b/mlir/lib/Transforms/Utils/LoopUtils.cpp
index 78df3d130f4a8..719a2ff73b83e 100644
--- a/mlir/lib/Transforms/Utils/LoopUtils.cpp
+++ b/mlir/lib/Transforms/Utils/LoopUtils.cpp
@@ -206,9 +206,9 @@ LogicalResult mlir::promoteIfSingleIteration(AffineForOp forOp) {
/// Promotes the loop body of a forOp to its containing block if the forOp
/// it can be determined that the loop has a single iteration.
LogicalResult mlir::promoteIfSingleIteration(scf::ForOp forOp) {
- auto lbCstOp = forOp.lowerBound().getDefiningOp<arith::ConstantIndexOp>();
- auto ubCstOp = forOp.upperBound().getDefiningOp<arith::ConstantIndexOp>();
- auto stepCstOp = forOp.step().getDefiningOp<arith::ConstantIndexOp>();
+ auto lbCstOp = forOp.getLowerBound().getDefiningOp<arith::ConstantIndexOp>();
+ auto ubCstOp = forOp.getUpperBound().getDefiningOp<arith::ConstantIndexOp>();
+ auto stepCstOp = forOp.getStep().getDefiningOp<arith::ConstantIndexOp>();
if (!lbCstOp || !ubCstOp || !stepCstOp || lbCstOp.value() < 0 ||
ubCstOp.value() < 0 || stepCstOp.value() < 0)
return failure();
@@ -999,7 +999,7 @@ static void getPerfectlyNestedLoopsImpl(
unsigned maxLoops = std::numeric_limits<unsigned>::max()) {
for (unsigned i = 0; i < maxLoops; ++i) {
forOps.push_back(rootForOp);
- Block &body = rootForOp.region().front();
+ Block &body = rootForOp.getRegion().front();
if (body.begin() != std::prev(body.end(), 2))
return;
@@ -1226,14 +1226,14 @@ LogicalResult mlir::loopUnrollByFactor(
// 'upperBoundUnrolled' and 'stepUnrolled' for static and dynamic cases.
OpBuilder boundsBuilder(forOp);
auto loc = forOp.getLoc();
- auto step = forOp.step();
+ auto step = forOp.getStep();
Value upperBoundUnrolled;
Value stepUnrolled;
bool generateEpilogueLoop = true;
- auto lbCstOp = forOp.lowerBound().getDefiningOp<arith::ConstantIndexOp>();
- auto ubCstOp = forOp.upperBound().getDefiningOp<arith::ConstantIndexOp>();
- auto stepCstOp = forOp.step().getDefiningOp<arith::ConstantIndexOp>();
+ auto lbCstOp = forOp.getLowerBound().getDefiningOp<arith::ConstantIndexOp>();
+ auto ubCstOp = forOp.getUpperBound().getDefiningOp<arith::ConstantIndexOp>();
+ auto stepCstOp = forOp.getStep().getDefiningOp<arith::ConstantIndexOp>();
if (lbCstOp && ubCstOp && stepCstOp) {
// Constant loop bounds computation.
int64_t lbCst = lbCstOp.value();
@@ -1264,8 +1264,8 @@ LogicalResult mlir::loopUnrollByFactor(
// Dynamic loop bounds computation.
// TODO: Add dynamic asserts for negative lb/ub/step, or
// consider using ceilDiv from AffineApplyExpander.
- auto lowerBound = forOp.lowerBound();
- auto upperBound = forOp.upperBound();
+ auto lowerBound = forOp.getLowerBound();
+ auto upperBound = forOp.getUpperBound();
Value
diff =
boundsBuilder.create<arith::SubIOp>(loc, upperBound, lowerBound);
Value tripCount = ceilDivPositive(boundsBuilder, loc,
diff , step);
@@ -1857,7 +1857,7 @@ stripmineSink(AffineForOp forOp, uint64_t factor,
static Loops stripmineSink(scf::ForOp forOp, Value factor,
ArrayRef<scf::ForOp> targets) {
- auto originalStep = forOp.step();
+ auto originalStep = forOp.getStep();
auto iv = forOp.getInductionVar();
OpBuilder b(forOp);
@@ -1871,11 +1871,11 @@ static Loops stripmineSink(scf::ForOp forOp, Value factor,
// Insert newForOp before the terminator of `t`.
auto b = OpBuilder::atBlockTerminator((t.getBody()));
- Value stepped = b.create<arith::AddIOp>(t.getLoc(), iv, forOp.step());
+ Value stepped = b.create<arith::AddIOp>(t.getLoc(), iv, forOp.getStep());
Value less = b.create<arith::CmpIOp>(t.getLoc(), arith::CmpIPredicate::slt,
- forOp.upperBound(), stepped);
+ forOp.getUpperBound(), stepped);
Value ub =
- b.create<SelectOp>(t.getLoc(), less, forOp.upperBound(), stepped);
+ b.create<SelectOp>(t.getLoc(), less, forOp.getUpperBound(), stepped);
// Splice [begin, begin + nOps - 1) into `newForOp` and replace uses.
auto newForOp = b.create<scf::ForOp>(t.getLoc(), iv, ub, originalStep);
@@ -1883,7 +1883,7 @@ static Loops stripmineSink(scf::ForOp forOp, Value factor,
newForOp.getBody()->getOperations().begin(),
t.getBody()->getOperations(), begin, std::next(begin, nOps - 1));
replaceAllUsesInRegionWith(iv, newForOp.getInductionVar(),
- newForOp.region());
+ newForOp.getRegion());
innerLoops.push_back(newForOp);
}
@@ -2050,9 +2050,9 @@ TileLoops mlir::extractFixedOuterLoops(scf::ForOp rootForOp,
auto forOp = forOps[i];
OpBuilder builder(forOp);
auto loc = forOp.getLoc();
- Value
diff = builder.create<arith::SubIOp>(loc, forOp.upperBound(),
- forOp.lowerBound());
- Value numIterations = ceilDivPositive(builder, loc,
diff , forOp.step());
+ Value
diff = builder.create<arith::SubIOp>(loc, forOp.getUpperBound(),
+ forOp.getLowerBound());
+ Value numIterations = ceilDivPositive(builder, loc,
diff , forOp.getStep());
Value iterationsPerBlock =
ceilDivPositive(builder, loc, numIterations, sizes[i]);
tileSizes.push_back(iterationsPerBlock);
@@ -2135,9 +2135,9 @@ static LoopParams normalizeLoop(OpBuilder &boundsBuilder,
static void normalizeLoop(scf::ForOp loop, scf::ForOp outer, scf::ForOp inner) {
OpBuilder builder(outer);
OpBuilder innerBuilder = OpBuilder::atBlockBegin(inner.getBody());
- auto loopPieces =
- normalizeLoop(builder, innerBuilder, loop.getLoc(), loop.lowerBound(),
- loop.upperBound(), loop.step(), loop.getInductionVar());
+ auto loopPieces = normalizeLoop(builder, innerBuilder, loop.getLoc(),
+ loop.getLowerBound(), loop.getUpperBound(),
+ loop.getStep(), loop.getInductionVar());
loop.setLowerBound(loopPieces.lowerBound);
loop.setUpperBound(loopPieces.upperBound);
@@ -2160,10 +2160,10 @@ void mlir::coalesceLoops(MutableArrayRef<scf::ForOp> loops) {
// of the number of iterations of all loops.
OpBuilder builder(outermost);
Location loc = outermost.getLoc();
- Value upperBound = outermost.upperBound();
+ Value upperBound = outermost.getUpperBound();
for (auto loop : loops.drop_front())
upperBound =
- builder.create<arith::MulIOp>(loc, upperBound, loop.upperBound());
+ builder.create<arith::MulIOp>(loc, upperBound, loop.getUpperBound());
outermost.setUpperBound(upperBound);
builder.setInsertionPointToStart(outermost.getBody());
@@ -2181,13 +2181,13 @@ void mlir::coalesceLoops(MutableArrayRef<scf::ForOp> loops) {
unsigned idx = loops.size() - i - 1;
if (i != 0)
previous = builder.create<arith::DivSIOp>(loc, previous,
- loops[idx + 1].upperBound());
+ loops[idx + 1].getUpperBound());
Value iv = (i == e - 1) ? previous
: builder.create<arith::RemSIOp>(
- loc, previous, loops[idx].upperBound());
+ loc, previous, loops[idx].getUpperBound());
replaceAllUsesInRegionWith(loops[idx].getInductionVar(), iv,
- loops.back().region());
+ loops.back().getRegion());
}
// 4. Move the operations from the innermost just above the second-outermost
@@ -2331,8 +2331,8 @@ void mlir::collapseParallelLoops(
OpBuilder insideLoopBuilder = OpBuilder::atBlockBegin(loops.getBody());
auto resultBounds =
normalizeLoop(outsideBuilder, insideLoopBuilder, loc,
- loops.lowerBound()[i], loops.upperBound()[i],
- loops.step()[i], loops.getBody()->getArgument(i));
+ loops.getLowerBound()[i], loops.getUpperBound()[i],
+ loops.getStep()[i], loops.getBody()->getArgument(i));
normalizedLowerBounds.push_back(resultBounds.lowerBound);
normalizedUpperBounds.push_back(resultBounds.upperBound);
@@ -2374,7 +2374,7 @@ void mlir::collapseParallelLoops(
Value iv = insideBuilder.create<arith::RemSIOp>(
loc, previous, normalizedUpperBounds[idx]);
replaceAllUsesInRegionWith(loops.getBody()->getArgument(idx), iv,
- loops.region());
+ loops.getRegion());
// Remove the effect of the current induction value to prepare for
// the next value.
@@ -2385,7 +2385,7 @@ void mlir::collapseParallelLoops(
// The final induction value is just the remaining value.
unsigned idx = combinedDimensions[i][0];
replaceAllUsesInRegionWith(loops.getBody()->getArgument(idx),
- previous, loops.region());
+ previous, loops.getRegion());
}
});
@@ -2419,12 +2419,12 @@ void mlir::mapLoopToProcessorIds(scf::ForOp forOp, ArrayRef<Value> processorId,
}
auto mulApplyOp = b.create<AffineApplyOp>(
- loc, mulMap, ValueRange{linearIndex, forOp.step()});
+ loc, mulMap, ValueRange{linearIndex, forOp.getStep()});
Value lb = b.create<AffineApplyOp>(
- loc, addMap, ValueRange{mulApplyOp, forOp.lowerBound()});
+ loc, addMap, ValueRange{mulApplyOp, forOp.getLowerBound()});
forOp.setLowerBound(lb);
- Value step = forOp.step();
+ Value step = forOp.getStep();
for (auto numProcs : numProcessors)
step = b.create<AffineApplyOp>(loc, mulMap, ValueRange{numProcs, step});
forOp.setStep(step);
More information about the Mlir-commits
mailing list