From c0342a2de8aa9ffe129bce50e9c90647a772bb2b Mon Sep 17 00:00:00 2001 From: Jacques Pienaar Date: Mon, 20 Dec 2021 08:03:43 -0800 Subject: [PATCH] [mlir] Switching accessors to prefixed form (NFC) Makes eventual prefixing flag flip smaller change. --- mlir/include/mlir/Dialect/SCF/SCFOps.td | 12 +- .../AffineToStandard/AffineToStandard.cpp | 39 +-- .../lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp | 14 +- .../ComplexToStandard/ComplexToStandard.cpp | 89 ++++--- mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp | 8 +- mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp | 24 +- mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp | 37 +-- .../lib/Conversion/SCFToStandard/SCFToStandard.cpp | 76 +++--- .../Conversion/ShapeToStandard/ShapeToStandard.cpp | 2 +- mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp | 8 +- mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp | 14 +- mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp | 4 +- .../Dialect/Async/Transforms/AsyncParallelFor.cpp | 32 +-- .../ComprehensiveBufferize/SCFInterfaceImpl.cpp | 23 +- .../lib/Dialect/Linalg/Transforms/HoistPadding.cpp | 22 +- mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp | 8 +- mlir/lib/Dialect/SCF/SCF.cpp | 291 +++++++++++---------- mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp | 16 +- .../SCF/Transforms/LoopCanonicalization.cpp | 16 +- mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp | 11 +- .../Dialect/SCF/Transforms/LoopRangeFolding.cpp | 6 +- .../Dialect/SCF/Transforms/LoopSpecialization.cpp | 35 +-- .../Dialect/SCF/Transforms/ParallelLoopFusion.cpp | 8 +- .../Dialect/SCF/Transforms/ParallelLoopTiling.cpp | 33 +-- .../SCF/Transforms/StructuralTypeConversions.cpp | 8 +- mlir/lib/Dialect/SCF/Transforms/Utils.cpp | 12 +- .../Transforms/SparseTensorConversion.cpp | 6 +- .../SparseTensor/Transforms/Sparsification.cpp | 18 +- mlir/lib/Target/Cpp/TranslateToCpp.cpp | 12 +- mlir/lib/Transforms/LoopCoalescing.cpp | 3 +- mlir/lib/Transforms/Utils/LoopUtils.cpp | 66 ++--- 31 files changed, 489 insertions(+), 464 deletions(-) diff --git a/mlir/include/mlir/Dialect/SCF/SCFOps.td b/mlir/include/mlir/Dialect/SCF/SCFOps.td index 508d2aa..01386ce 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 0467dd9..8b48549 100644 --- a/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp +++ b/mlir/lib/Conversion/AffineToStandard/AffineToStandard.cpp @@ -365,9 +365,9 @@ public: auto scfForOp = rewriter.create(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 @@ public: 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 @@ public: // 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 @@ public: rewriter.setInsertionPoint(&parOp.getBody()->back()); auto reduceOp = rewriter.create( 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(loc, reductionResult); } - rewriter.replaceOp(op, parOp.results()); + rewriter.replaceOp(op, parOp.getResults()); return success(); } }; @@ -512,15 +512,16 @@ public: bool hasElseRegion = !op.elseRegion().empty(); auto ifOp = rewriter.create(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 3753c4c..592d183 100644 --- a/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp +++ b/mlir/lib/Conversion/ComplexToLLVM/ComplexToLLVM.cpp @@ -64,7 +64,7 @@ struct AbsOpConversion : public ConvertOpToLLVMPattern { 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 { 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 { 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 { 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 8bbc6af..2766c12 100644 --- a/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp +++ b/mlir/lib/Conversion/ComplexToStandard/ComplexToStandard.cpp @@ -32,8 +32,10 @@ struct AbsOpConversion : public OpConversionPattern { auto loc = op.getLoc(); auto type = op.getType(); - Value real = rewriter.create(loc, type, adaptor.complex()); - Value imag = rewriter.create(loc, type, adaptor.complex()); + Value real = + rewriter.create(loc, type, adaptor.getComplex()); + Value imag = + rewriter.create(loc, type, adaptor.getComplex()); Value realSqr = rewriter.create(loc, real, real); Value imagSqr = rewriter.create(loc, imag, imag); Value sqNorm = rewriter.create(loc, realSqr, imagSqr); @@ -54,13 +56,15 @@ struct ComparisonOpConversion : public OpConversionPattern { matchAndRewrite(ComparisonOp op, typename ComparisonOp::Adaptor adaptor, ConversionPatternRewriter &rewriter) const override { auto loc = op.getLoc(); - auto type = - adaptor.lhs().getType().template cast().getElementType(); - - Value realLhs = rewriter.create(loc, type, adaptor.lhs()); - Value imagLhs = rewriter.create(loc, type, adaptor.lhs()); - Value realRhs = rewriter.create(loc, type, adaptor.rhs()); - Value imagRhs = rewriter.create(loc, type, adaptor.rhs()); + auto type = adaptor.getLhs() + .getType() + .template cast() + .getElementType(); + + Value realLhs = rewriter.create(loc, type, adaptor.getLhs()); + Value imagLhs = rewriter.create(loc, type, adaptor.getLhs()); + Value realRhs = rewriter.create(loc, type, adaptor.getRhs()); + Value imagRhs = rewriter.create(loc, type, adaptor.getRhs()); Value realComparison = rewriter.create(loc, p, realLhs, realRhs); Value imagComparison = @@ -82,16 +86,16 @@ struct BinaryComplexOpConversion : public OpConversionPattern { LogicalResult matchAndRewrite(BinaryComplexOp op, typename BinaryComplexOp::Adaptor adaptor, ConversionPatternRewriter &rewriter) const override { - auto type = adaptor.lhs().getType().template cast(); + auto type = adaptor.getLhs().getType().template cast(); auto elementType = type.getElementType().template cast(); mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter); - Value realLhs = b.create(elementType, adaptor.lhs()); - Value realRhs = b.create(elementType, adaptor.rhs()); + Value realLhs = b.create(elementType, adaptor.getLhs()); + Value realRhs = b.create(elementType, adaptor.getRhs()); Value resultReal = b.create(elementType, realLhs, realRhs); - Value imagLhs = b.create(elementType, adaptor.lhs()); - Value imagRhs = b.create(elementType, adaptor.rhs()); + Value imagLhs = b.create(elementType, adaptor.getLhs()); + Value imagRhs = b.create(elementType, adaptor.getRhs()); Value resultImag = b.create(elementType, imagLhs, imagRhs); rewriter.replaceOpWithNewOp(op, type, resultReal, @@ -107,17 +111,17 @@ struct DivOpConversion : public OpConversionPattern { matchAndRewrite(complex::DivOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { auto loc = op.getLoc(); - auto type = adaptor.lhs().getType().cast(); + auto type = adaptor.getLhs().getType().cast(); auto elementType = type.getElementType().cast(); Value lhsReal = - rewriter.create(loc, elementType, adaptor.lhs()); + rewriter.create(loc, elementType, adaptor.getLhs()); Value lhsImag = - rewriter.create(loc, elementType, adaptor.lhs()); + rewriter.create(loc, elementType, adaptor.getLhs()); Value rhsReal = - rewriter.create(loc, elementType, adaptor.rhs()); + rewriter.create(loc, elementType, adaptor.getRhs()); Value rhsImag = - rewriter.create(loc, elementType, adaptor.rhs()); + rewriter.create(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 { matchAndRewrite(complex::ExpOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { auto loc = op.getLoc(); - auto type = adaptor.complex().getType().cast(); + auto type = adaptor.getComplex().getType().cast(); auto elementType = type.getElementType().cast(); Value real = - rewriter.create(loc, elementType, adaptor.complex()); + rewriter.create(loc, elementType, adaptor.getComplex()); Value imag = - rewriter.create(loc, elementType, adaptor.complex()); + rewriter.create(loc, elementType, adaptor.getComplex()); Value expReal = rewriter.create(loc, real); Value cosImag = rewriter.create(loc, imag); Value resultReal = rewriter.create(loc, expReal, cosImag); @@ -351,14 +355,14 @@ struct LogOpConversion : public OpConversionPattern { LogicalResult matchAndRewrite(complex::LogOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { - auto type = adaptor.complex().getType().cast(); + auto type = adaptor.getComplex().getType().cast(); auto elementType = type.getElementType().cast(); mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter); - Value abs = b.create(elementType, adaptor.complex()); + Value abs = b.create(elementType, adaptor.getComplex()); Value resultReal = b.create(elementType, abs); - Value real = b.create(elementType, adaptor.complex()); - Value imag = b.create(elementType, adaptor.complex()); + Value real = b.create(elementType, adaptor.getComplex()); + Value imag = b.create(elementType, adaptor.getComplex()); Value resultImag = b.create(elementType, imag, real); rewriter.replaceOpWithNewOp(op, type, resultReal, resultImag); @@ -372,12 +376,12 @@ struct Log1pOpConversion : public OpConversionPattern { LogicalResult matchAndRewrite(complex::Log1pOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { - auto type = adaptor.complex().getType().cast(); + auto type = adaptor.getComplex().getType().cast(); auto elementType = type.getElementType().cast(); mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter); - Value real = b.create(elementType, adaptor.complex()); - Value imag = b.create(elementType, adaptor.complex()); + Value real = b.create(elementType, adaptor.getComplex()); + Value imag = b.create(elementType, adaptor.getComplex()); Value one = b.create(elementType, b.getFloatAttr(elementType, 1)); Value realPlusOne = b.create(real, one); @@ -394,16 +398,16 @@ struct MulOpConversion : public OpConversionPattern { matchAndRewrite(complex::MulOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter); - auto type = adaptor.lhs().getType().cast(); + auto type = adaptor.getLhs().getType().cast(); auto elementType = type.getElementType().cast(); - Value lhsReal = b.create(elementType, adaptor.lhs()); + Value lhsReal = b.create(elementType, adaptor.getLhs()); Value lhsRealAbs = b.create(lhsReal); - Value lhsImag = b.create(elementType, adaptor.lhs()); + Value lhsImag = b.create(elementType, adaptor.getLhs()); Value lhsImagAbs = b.create(lhsImag); - Value rhsReal = b.create(elementType, adaptor.rhs()); + Value rhsReal = b.create(elementType, adaptor.getRhs()); Value rhsRealAbs = b.create(rhsReal); - Value rhsImag = b.create(elementType, adaptor.rhs()); + Value rhsImag = b.create(elementType, adaptor.getRhs()); Value rhsImagAbs = b.create(rhsImag); Value lhsRealTimesRhsReal = b.create(lhsReal, rhsReal); @@ -567,13 +571,13 @@ struct NegOpConversion : public OpConversionPattern { matchAndRewrite(complex::NegOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { auto loc = op.getLoc(); - auto type = adaptor.complex().getType().cast(); + auto type = adaptor.getComplex().getType().cast(); auto elementType = type.getElementType().cast(); Value real = - rewriter.create(loc, elementType, adaptor.complex()); + rewriter.create(loc, elementType, adaptor.getComplex()); Value imag = - rewriter.create(loc, elementType, adaptor.complex()); + rewriter.create(loc, elementType, adaptor.getComplex()); Value negReal = rewriter.create(loc, real); Value negImag = rewriter.create(loc, imag); rewriter.replaceOpWithNewOp(op, type, negReal, negImag); @@ -587,12 +591,12 @@ struct SignOpConversion : public OpConversionPattern { LogicalResult matchAndRewrite(complex::SignOp op, OpAdaptor adaptor, ConversionPatternRewriter &rewriter) const override { - auto type = adaptor.complex().getType().cast(); + auto type = adaptor.getComplex().getType().cast(); auto elementType = type.getElementType().cast(); mlir::ImplicitLocOpBuilder b(op.getLoc(), rewriter); - Value real = b.create(elementType, adaptor.complex()); - Value imag = b.create(elementType, adaptor.complex()); + Value real = b.create(elementType, adaptor.getComplex()); + Value imag = b.create(elementType, adaptor.getComplex()); Value zero = b.create(elementType, b.getZeroAttr(elementType)); Value realIsZero = @@ -600,11 +604,12 @@ struct SignOpConversion : public OpConversionPattern { Value imagIsZero = b.create(arith::CmpFPredicate::OEQ, imag, zero); Value isZero = b.create(realIsZero, imagIsZero); - auto abs = b.create(elementType, adaptor.complex()); + auto abs = b.create(elementType, adaptor.getComplex()); Value realSign = b.create(real, abs); Value imagSign = b.create(imag, abs); Value sign = b.create(type, realSign, imagSign); - rewriter.replaceOpWithNewOp(op, isZero, adaptor.complex(), sign); + rewriter.replaceOpWithNewOp(op, isZero, adaptor.getComplex(), + sign); return success(); } }; diff --git a/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp b/mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp index 2e46ca1..7243c25 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(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 657f041..16fbb3e 100644 --- a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp +++ b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp @@ -119,7 +119,7 @@ matchSelectReduction(Block &block, ArrayRef 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( - 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(reduction)) { omp::ReductionDeclareOp decl = createDecl(builder, symbolTable, reduce, @@ -335,7 +335,7 @@ struct ParallelOpLowering : public OpRewritePattern { { 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( parallelOp.getBody()->getTerminator(), ValueRange()); @@ -362,7 +362,7 @@ struct ParallelOpLowering : public OpRewritePattern { reductionVariables.reserve(parallelOp.getNumReductions()); Value token = rewriter.create( 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()) && "cannot create a reduction variable if the type is not an LLVM " @@ -382,7 +382,7 @@ struct ParallelOpLowering : public OpRewritePattern { scf::ReduceOp reduceOp = std::get<0>(pair); rewriter.setInsertionPoint(reduceOp); rewriter.replaceOpWithNewOp( - 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 { { 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( parallelOp.getBody()->getTerminator(), ValueRange()); @@ -403,11 +403,11 @@ struct ParallelOpLowering : public OpRewritePattern { // Replace the loop. auto loop = rewriter.create( - parallelOp.getLoc(), parallelOp.lowerBound(), parallelOp.upperBound(), - parallelOp.step()); + parallelOp.getLoc(), parallelOp.getLowerBound(), + parallelOp.getUpperBound(), parallelOp.getStep()); rewriter.create(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 ffa50ca..fd6ec82 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 args(1, adaptor.lowerBound()); - args.append(adaptor.initArgs().begin(), adaptor.initArgs().end()); + SmallVector 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(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( - loc, rewriter.getI1Type(), newIndVar, adaptor.upperBound()); + loc, rewriter.getI1Type(), newIndVar, adaptor.getUpperBound()); rewriter.create( loc, cmpOp, body, ArrayRef(), mergeBlock, ArrayRef()); @@ -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( - loc, newIndVar.getType(), newIndVar, adaptor.step()); + loc, newIndVar.getType(), newIndVar, adaptor.getStep()); rewriter.create(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 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(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(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(loc, adaptor.condition(), + rewriter.create(loc, adaptor.getCondition(), thenBlock, ArrayRef(), elseBlock, ArrayRef()); SmallVector 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(beforeBlock.getTerminator()); SmallVector 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(afterBlock.getTerminator()); SmallVector 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(loc, &beforeBlock, adaptor.inits()); + rewriter.create(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 7e9c698..1994006 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(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(loc, ifOp.condition(), thenBlock, + rewriter.create(loc, ifOp.getCondition(), thenBlock, /*trueArgs=*/ArrayRef(), elseBlock, /*falseArgs=*/ArrayRef()); @@ -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(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 iterArgs = llvm::to_vector<4>(parallelOp.initVals()); + SmallVector iterArgs = llvm::to_vector<4>(parallelOp.getInitVals()); SmallVector ivs; ivs.reserve(parallelOp.getNumLoops()); bool first = true; SmallVector 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(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(loc, before, whileOp.inits()); + rewriter.create(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(beforeLast->getTerminator()); - rewriter.replaceOpWithNewOp(condOp, condOp.condition(), after, - condOp.args(), continuation, - ValueRange()); + rewriter.replaceOpWithNewOp(condOp, condOp.getCondition(), + after, condOp.getArgs(), + continuation, ValueRange()); rewriter.setInsertionPointToEnd(afterLast); auto yieldOp = cast(afterLast->getTerminator()); - rewriter.replaceOpWithNewOp(yieldOp, before, yieldOp.results()); + rewriter.replaceOpWithNewOp(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(&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(whileOp.getLoc(), before, whileOp.inits()); + rewriter.create(whileOp.getLoc(), before, whileOp.getInits()); // Loop around the "before" region based on condition. rewriter.setInsertionPointToEnd(beforeLast); auto condOp = cast(beforeLast->getTerminator()); - rewriter.replaceOpWithNewOp(condOp, condOp.condition(), before, - condOp.args(), continuation, - ValueRange()); + rewriter.replaceOpWithNewOp(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 deb4cd5..7e0c4a7 100644 --- a/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp +++ b/mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp @@ -318,7 +318,7 @@ LogicalResult IsBroadcastableOpConverter::matchAndRewrite( b.create(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 78981fd0..f05226d6 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 types = {elementTy, elementTy, elementTy}; auto whileOp = rewriter.create(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 ef5ccf9..2cf226b 100644 --- a/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp +++ b/mlir/lib/Conversion/TosaToSCF/TosaToSCF.cpp @@ -72,8 +72,10 @@ public: auto newIf = rewriter.create(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 @@ public: PatternRewriter &rewriter) const final { auto newWhile = rewriter.create( 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 4c50b4f..985cfc9 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(loop.getLoc(), loop.lowerBound(), loop.upperBound(), - loop.step(), operands); + b.create(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 ec50353..f0b4244 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 captures; - getUsedValuesDefinedAbove(op.region(), op.region(), captures); + getUsedValuesDefinedAbove(op.getRegion(), op.getRegion(), captures); SmallVector 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(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 &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 { SmallVector 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 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(ub, lb); tripCounts[i] = b.createOrFold(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 f3e4aa4..8a2630c 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(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( - 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(ifOp.getLoc(), newTypes, ifOp.condition(), + rewriter.create(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 indices; - for (const auto &it : llvm::enumerate(forOp.initArgs())) + for (const auto &it : llvm::enumerate(forOp.getInitArgs())) if (it.value().getType().isa()) indices.insert(it.index()); @@ -307,12 +308,12 @@ struct ForOpInterface // Construct a new scf.for op with memref instead of tensor values. SmallVector 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(forOp.getLoc(), forOp.lowerBound(), - forOp.upperBound(), forOp.step(), initArgs); + auto newForOp = rewriter.create( + 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(loopBody->getTerminator()); rewriter.setInsertionPoint(yieldOp); SmallVector yieldValues = - convert(yieldOp.results(), [&](Value val, int64_t index) { + convert(yieldOp.getResults(), [&](Value val, int64_t index) { return rewriter.create( 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 7abcc8a..a4edd8a 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 boundOperands; - getUpperBoundForIndex(forOp.upperBound(), boundMap, boundOperands); + getUpperBoundForIndex(forOp.getUpperBound(), boundMap, boundOperands); Value ubVal = b.createOrFold(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( - (ub - lb).ceilDiv(step), - ValueRange{forOp.lowerBound(), ubVal, cast(forOp).step()}); + (ub - lb).ceilDiv(step), ValueRange{forOp.getLowerBound(), ubVal, + cast(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(loc, (iv - lb).ceilDiv(step), ValueRange{ivVal, lbVal, stepVal}); @@ -434,10 +434,10 @@ FailureOr mlir::linalg::hoistPaddingOnTensors(PadTensorOp opToHoist, continue; } // Create a packing loop that takes `packedTensor` as iteration argument. - auto clonedForOp = - b.create(loc, bvm.lookupOrDefault(forOp.lowerBound()), - bvm.lookupOrDefault(forOp.upperBound()), - bvm.lookupOrDefault(forOp.step()), packedTensor); + auto clonedForOp = b.create( + 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 eefc51d..97b586c 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(forOp.region().front().getTerminator()); + auto yieldOp = cast(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 cea88d1..95a4c9d 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 { 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 { Block *postBlock = rewriter.splitBlock(prevBlock, op->getIterator()); rewriter.setInsertionPointToEnd(prevBlock); - rewriter.create(op.getLoc(), &op.region().front()); + rewriter.create(op.getLoc(), &op.getRegion().front()); - for (Block &blk : op.region()) { + for (Block &blk : op.getRegion()) { if (YieldOp yieldOp = dyn_cast(blk.getTerminator())) { rewriter.setInsertionPoint(yieldOp); rewriter.create(yieldOp.getLoc(), postBlock, - yieldOp.results()); + yieldOp.getResults()); rewriter.eraseOp(yieldOp); } } - rewriter.inlineRegionBefore(op.region(), postBlock); + rewriter.inlineRegionBefore(op.getRegion(), postBlock); SmallVector blockArgs; for (auto res : op.getResults()) @@ -242,7 +242,7 @@ void ExecuteRegionOp::getCanonicalizationPatterns(RewritePatternSet &results, MutableOperandRange ConditionOp::getMutableSuccessorOperands(Optional 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()) + if (auto cst = op.getStep().getDefiningOp()) 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 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 { 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(block.getTerminator()); // An internal flat vector of block transfer @@ -640,9 +640,9 @@ struct ForOpIterArgsFolder : public OpRewritePattern { return failure(); scf::ForOp newForOp = rewriter.create( - 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 { } } - 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 { 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(); - auto ub = op.upperBound().getDefiningOp(); + auto lb = op.getLowerBound().getDefiningOp(); + auto ub = op.getUpperBound().getDefiningOp(); if (!lb || !ub) return failure(); @@ -722,7 +722,7 @@ struct SimplifyTrivialLoops : public OpRewritePattern { return success(); } - auto step = op.step().getDefiningOp(); + auto step = op.getStep().getDefiningOp(); if (!step) return failure(); @@ -732,7 +732,7 @@ struct SimplifyTrivialLoops : public OpRewritePattern { if ((lbValue + stepValue).sge(ubValue)) { SmallVector 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( - 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 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 { 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 replacements; for (BlockArgument bbArg : forOp.getRegionIterArgs()) { unsigned idx = bbArg.getArgNumber() - /*numIv=*/1; - auto yieldOp = cast(forOp.region().front().getTerminator()); + auto yieldOp = + cast(forOp.getRegion().front().getTerminator()); Value yieldVal = yieldOp->getOperand(idx); auto tensorLoadOp = yieldVal.getDefiningOp(); bool isTensor = bbArg.getType().isa(); @@ -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 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 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 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 { // Create a replacement operation with empty then and else regions. auto emptyBuilder = [](OpBuilder &, Location) {}; - auto newOp = rewriter.create(op.getLoc(), newTypes, op.condition(), + auto newOp = rewriter.create(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 { LogicalResult matchAndRewrite(IfOp op, PatternRewriter &rewriter) const override { - auto constant = op.condition().getDefiningOp(); + auto constant = op.getCondition().getDefiningOp(); if (!constant) return failure(); if (constant.getValue().cast().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 { 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(op.thenRegion().front().getTerminator()) + cast(op.getThenRegion().front().getTerminator()) .getOperands(); auto elseYieldArgs = - cast(op.elseRegion().front().getTerminator()) + cast(op.getElseRegion().front().getTerminator()) .getOperands(); SmallVector results(op->getNumResults()); assert(thenYieldArgs.size() == results.size()); @@ -1330,7 +1331,7 @@ struct ConditionPropagation : public OpRewritePattern { 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()) + if (op.getCondition().getDefiningOp()) return failure(); bool changed = false; @@ -1342,8 +1343,8 @@ struct ConditionPropagation : public OpRewritePattern { 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 { 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 { if (op.getNumResults() == 0) return failure(); - auto trueYield = cast(op.thenRegion().back().getTerminator()); + auto trueYield = + cast(op.getThenRegion().back().getTerminator()); auto falseYield = - cast(op.elseRegion().back().getTerminator()); + cast(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 { if (!trueVal && falseVal) { if (!opResult.use_empty()) { Value notCond = rewriter.create( - op.getLoc(), op.condition(), + op.getLoc(), op.getCondition(), rewriter.create( op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 1))); opResult.replaceAllUsesWith(notCond); @@ -1460,7 +1462,7 @@ struct ReplaceIfYieldWithConditionOrValue : public OpRewritePattern { } 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 { 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 { llvm::append_range(mergedTypes, nextIf.getResultTypes()); IfOp combinedIf = rewriter.create( - 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 { 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 { 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(&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 reductions(body->getOps()); - 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 ops) { @@ -1846,11 +1848,11 @@ struct CollapseSingleIterationLoops : public OpRewritePattern { SmallVector newLowerBounds; SmallVector newUpperBounds; SmallVector 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 { } } // 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 results; - results.reserve(op.initVals().size()); + results.reserve(op.getInitVals().size()); for (auto &bodyOp : op.getLoopBody().front().without_terminator()) { auto reduce = dyn_cast(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(reduceBlock.getTerminator()).result()); + cast(reduceBlock.getTerminator()).getResult()); results.push_back(result); } rewriter.replaceOp(op, results); @@ -1906,11 +1908,11 @@ struct CollapseSingleIterationLoops : public OpRewritePattern { // Replace the parallel loop by lower-dimensional parallel loop. auto newOp = rewriter.create(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 { 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 { }; 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 { 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(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(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(before().front().getTerminator()); + return cast(getBefore().front().getTerminator()); } Block::BlockArgListType WhileOp::getAfterArguments() { - return after().front().getArguments(); + return getAfter().front().getArguments(); } void WhileOp::getSuccessorRegions(Optional index, @@ -2105,18 +2110,18 @@ void WhileOp::getSuccessorRegions(Optional 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( - op, op.before(), + op, op.getBefore(), "expects the 'before' region to terminate with 'scf.condition'"); if (!beforeTerminator) return failure(); auto afterTerminator = verifyAndGetTerminator( - 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 { 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( - 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 { 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 newResultsIndices; @@ -2338,15 +2343,15 @@ struct WhileUnusedResult : public OpRewritePattern { { OpBuilder::InsertionGuard g(rewriter); rewriter.setInsertionPoint(term); - rewriter.replaceOpWithNewOp(term, term.condition(), + rewriter.replaceOpWithNewOp(term, term.getCondition(), newTermArgs); } auto newWhile = - rewriter.create(op.getLoc(), newResultTypes, op.inits()); + rewriter.create(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 { 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 44e3b51..a3f3070 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 { // variable is placed first, followed by the forOp.iterArgs. SmallVector 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 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(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( whileOp.getLoc(), arith::CmpIPredicate::slt, - beforeBlock->getArgument(0), forOp.upperBound()); + beforeBlock->getArgument(0), forOp.getUpperBound()); rewriter.create(whileOp.getLoc(), cmpOp.getResult(), beforeBlock->getArguments()); @@ -60,12 +60,12 @@ struct ForLoopLoweringPattern : public OpRewritePattern { // 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( - 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 7c903b9..1c13397 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(forOp.getBody()->getTerminator()); - assert(arg < static_cast(yieldOp.results().size()) && + assert(arg < static_cast(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 { 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 ba44b4a..321d953 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(); + forOp.getUpperBound().getDefiningOp(); auto lowerBoundCst = - forOp.lowerBound().getDefiningOp(); - auto stepCst = forOp.step().getDefiningOp(); + forOp.getLowerBound().getDefiningOp(); + auto stepCst = forOp.getStep().getDefiningOp(); 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(forOp.getLoc(), ub - maxStage * step); - auto newForOp = rewriter.create( - forOp.getLoc(), forOp.lowerBound(), newUb, forOp.step(), newLoopArg); + auto newForOp = + rewriter.create(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 d65b78e..bca5abd 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(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 6461ea9..da15c49 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 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(); 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(op.getLoc(), std::get<1>(bound)); Value cmp = b.create(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(); 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( - loc, modMap, - ValueRange{forOp.lowerBound(), forOp.upperBound(), forOp.step()}); + splitBound = b.createOrFold(loc, modMap, + ValueRange{forOp.getLowerBound(), + forOp.getUpperBound(), + forOp.getStep()}); // Create ForOp for partial iteration. b.setInsertionPointAfter(forOp); partialIteration = cast(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 32c5abc..f4f8751 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 45ff2a4..998c736 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 tileSizes, OpBuilder b(op); auto zero = b.create(op.getLoc(), 0); SmallVector 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(op.getLoc(), tileSizes[i])); @@ -69,13 +69,13 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef tileSizes, // Create the outer loop with adjusted steps. SmallVector 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(op.getLoc(), std::get<0>(step), std::get<1>(step))); } - auto outerLoop = b.create(op.getLoc(), op.lowerBound(), - op.upperBound(), newSteps); + auto outerLoop = b.create(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 tileSizes, // Create the inner loop with adjusted bounds. SmallVector 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 tileSizes, } auto innerLoop = b.create( op.getLoc(), SmallVector(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 tileSizes, Value inbound = b.create(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 tileSizes, auto ifInbound = b.create(op.getLoc(), /*resultTypes*/ ArrayRef{}, 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 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 b84a6cb..3a963c7 100644 --- a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp +++ b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp @@ -102,10 +102,10 @@ public: // See comments in the ForOp pattern for why we clone without regions and // then inline. IfOp newOp = cast(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 00fa22b..c8e557c 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(loop.getLoc(), loop.lowerBound(), loop.upperBound(), - loop.step(), operands); + b.create(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 92a1c49..047142b 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(loc, tensor, ivs); Value cond = genIsNonzero(rewriter, loc, val); scf::IfOp ifOp = rewriter.create(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 { SmallVector noArgs; SmallVector noTypes; auto whileOp = rewriter.create(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(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(loc); diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp index ac01d5d..6568633 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(loc, rewriter.getIndexType(), cond, /*else=*/true); // True branch. - rewriter.setInsertionPointToStart(&ifOp.thenRegion().front()); + rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front()); rewriter.create(loc, tval, codegen.expFilled, index); rewriter.create(loc, index, codegen.expAdded, codegen.expCount); @@ -769,7 +769,7 @@ static void genInsertionStore(CodeGen &codegen, PatternRewriter &rewriter, Value add = rewriter.create(loc, codegen.expCount, one); rewriter.create(loc, add); // False branch. - rewriter.setInsertionPointToStart(&ifOp.elseRegion().front()); + rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front()); rewriter.create(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(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(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(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(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 90f4f30..bf2a2e8 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 f930c53..32a7e52 100644 --- a/mlir/lib/Transforms/LoopCoalescing.cpp +++ b/mlir/lib/Transforms/LoopCoalescing.cpp @@ -43,7 +43,8 @@ struct LoopCoalescingPass : public LoopCoalescingBase { 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 78df3d1..719a2ff 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(); - auto ubCstOp = forOp.upperBound().getDefiningOp(); - auto stepCstOp = forOp.step().getDefiningOp(); + auto lbCstOp = forOp.getLowerBound().getDefiningOp(); + auto ubCstOp = forOp.getUpperBound().getDefiningOp(); + auto stepCstOp = forOp.getStep().getDefiningOp(); 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::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(); - auto ubCstOp = forOp.upperBound().getDefiningOp(); - auto stepCstOp = forOp.step().getDefiningOp(); + auto lbCstOp = forOp.getLowerBound().getDefiningOp(); + auto ubCstOp = forOp.getUpperBound().getDefiningOp(); + auto stepCstOp = forOp.getStep().getDefiningOp(); 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(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 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(t.getLoc(), iv, forOp.step()); + Value stepped = b.create(t.getLoc(), iv, forOp.getStep()); Value less = b.create(t.getLoc(), arith::CmpIPredicate::slt, - forOp.upperBound(), stepped); + forOp.getUpperBound(), stepped); Value ub = - b.create(t.getLoc(), less, forOp.upperBound(), stepped); + b.create(t.getLoc(), less, forOp.getUpperBound(), stepped); // Splice [begin, begin + nOps - 1) into `newForOp` and replace uses. auto newForOp = b.create(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(loc, forOp.upperBound(), - forOp.lowerBound()); - Value numIterations = ceilDivPositive(builder, loc, diff, forOp.step()); + Value diff = builder.create(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 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(loc, upperBound, loop.upperBound()); + builder.create(loc, upperBound, loop.getUpperBound()); outermost.setUpperBound(upperBound); builder.setInsertionPointToStart(outermost.getBody()); @@ -2181,13 +2181,13 @@ void mlir::coalesceLoops(MutableArrayRef loops) { unsigned idx = loops.size() - i - 1; if (i != 0) previous = builder.create(loc, previous, - loops[idx + 1].upperBound()); + loops[idx + 1].getUpperBound()); Value iv = (i == e - 1) ? previous : builder.create( - 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( 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 processorId, } auto mulApplyOp = b.create( - loc, mulMap, ValueRange{linearIndex, forOp.step()}); + loc, mulMap, ValueRange{linearIndex, forOp.getStep()}); Value lb = b.create( - 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(loc, mulMap, ValueRange{numProcs, step}); forOp.setStep(step); -- 2.7.4