[Mlir-commits] [mlir] 588845d - [mlir][NFC] update `mlir/Dialect` create APIs (20/n) (#149927)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Thu Jul 24 05:10:01 PDT 2025
Author: Maksim Levental
Date: 2025-07-24T07:09:58-05:00
New Revision: 588845defd09359a8b87db339b563af848cf45a7
URL: https://github.com/llvm/llvm-project/commit/588845defd09359a8b87db339b563af848cf45a7
DIFF: https://github.com/llvm/llvm-project/commit/588845defd09359a8b87db339b563af848cf45a7.diff
LOG: [mlir][NFC] update `mlir/Dialect` create APIs (20/n) (#149927)
See https://github.com/llvm/llvm-project/pull/147168 for more info.
Added:
Modified:
mlir/lib/Dialect/SCF/IR/SCF.cpp
mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp
mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp
mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
mlir/lib/Dialect/SCF/Transforms/ForallToParallel.cpp
mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp
mlir/lib/Dialect/SCF/Transforms/UpliftWhileToFor.cpp
mlir/lib/Dialect/SCF/Transforms/WrapInZeroTripCheck.cpp
mlir/lib/Dialect/SCF/Utils/Utils.cpp
mlir/lib/Dialect/SMT/IR/SMTDialect.cpp
mlir/lib/Dialect/SMT/IR/SMTOps.cpp
mlir/lib/Dialect/Shape/IR/Shape.cpp
mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp
mlir/lib/Dialect/Shape/Transforms/OutlineShapeComputation.cpp
mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp
Removed:
################################################################################
diff --git a/mlir/lib/Dialect/SCF/IR/SCF.cpp b/mlir/lib/Dialect/SCF/IR/SCF.cpp
index e282ca4d938f1..759e58b617578 100644
--- a/mlir/lib/Dialect/SCF/IR/SCF.cpp
+++ b/mlir/lib/Dialect/SCF/IR/SCF.cpp
@@ -84,7 +84,7 @@ void SCFDialect::initialize() {
/// Default callback for IfOp builders. Inserts a yield without arguments.
void mlir::scf::buildTerminatedBody(OpBuilder &builder, Location loc) {
- builder.create<scf::YieldOp>(loc);
+ scf::YieldOp::create(builder, loc);
}
/// Verifies that the first block of the given `region` is terminated by a
@@ -240,13 +240,13 @@ struct MultiBlockExecuteInliner : public OpRewritePattern<ExecuteRegionOp> {
Block *postBlock = rewriter.splitBlock(prevBlock, op->getIterator());
rewriter.setInsertionPointToEnd(prevBlock);
- rewriter.create<cf::BranchOp>(op.getLoc(), &op.getRegion().front());
+ cf::BranchOp::create(rewriter, op.getLoc(), &op.getRegion().front());
for (Block &blk : op.getRegion()) {
if (YieldOp yieldOp = dyn_cast<YieldOp>(blk.getTerminator())) {
rewriter.setInsertionPoint(yieldOp);
- rewriter.create<cf::BranchOp>(yieldOp.getLoc(), postBlock,
- yieldOp.getResults());
+ cf::BranchOp::create(rewriter, yieldOp.getLoc(), postBlock,
+ yieldOp.getResults());
rewriter.eraseOp(yieldOp);
}
}
@@ -556,8 +556,8 @@ ForOp::replaceWithAdditionalYields(RewriterBase &rewriter,
rewriter.setInsertionPoint(getOperation());
auto inits = llvm::to_vector(getInitArgs());
inits.append(newInitOperands.begin(), newInitOperands.end());
- scf::ForOp newLoop = rewriter.create<scf::ForOp>(
- getLoc(), getLowerBound(), getUpperBound(), getStep(), inits,
+ scf::ForOp newLoop = scf::ForOp::create(
+ rewriter, getLoc(), getLowerBound(), getUpperBound(), getStep(), inits,
[](OpBuilder &, Location, Value, ValueRange) {});
newLoop->setAttrs(getPrunedAttributeList(getOperation(), {}));
@@ -672,8 +672,8 @@ void mlir::scf::promote(RewriterBase &rewriter, scf::ForallOp forallOp) {
Value dst = parallelInsertSliceOp.getDest();
Value src = parallelInsertSliceOp.getSource();
if (llvm::isa<TensorType>(src.getType())) {
- results.push_back(rewriter.create<tensor::InsertSliceOp>(
- forallOp.getLoc(), dst.getType(), src, dst,
+ results.push_back(tensor::InsertSliceOp::create(
+ rewriter, forallOp.getLoc(), dst.getType(), src, dst,
parallelInsertSliceOp.getOffsets(), parallelInsertSliceOp.getSizes(),
parallelInsertSliceOp.getStrides(),
parallelInsertSliceOp.getStaticOffsets(),
@@ -721,8 +721,8 @@ LoopNest mlir::scf::buildLoopNest(
ValueRange currentIterArgs = iterArgs;
Location currentLoc = loc;
for (unsigned i = 0, e = lbs.size(); i < e; ++i) {
- auto loop = builder.create<scf::ForOp>(
- currentLoc, lbs[i], ubs[i], steps[i], currentIterArgs,
+ auto loop = scf::ForOp::create(
+ builder, currentLoc, lbs[i], ubs[i], steps[i], currentIterArgs,
[&](OpBuilder &nestedBuilder, Location nestedLoc, Value iv,
ValueRange args) {
ivs.push_back(iv);
@@ -741,7 +741,7 @@ LoopNest mlir::scf::buildLoopNest(
// For all loops but the innermost, yield the results of the nested loop.
for (unsigned i = 0, e = loops.size() - 1; i < e; ++i) {
builder.setInsertionPointToEnd(loops[i].getBody());
- builder.create<scf::YieldOp>(loc, loops[i + 1].getResults());
+ scf::YieldOp::create(builder, loc, loops[i + 1].getResults());
}
// In the body of the innermost loop, call the body building function if any
@@ -755,7 +755,7 @@ LoopNest mlir::scf::buildLoopNest(
"loop nest body must return as many values as loop has iteration "
"arguments");
builder.setInsertionPointToEnd(loops.back().getBody());
- builder.create<scf::YieldOp>(loc, results);
+ scf::YieldOp::create(builder, loc, results);
// Return the loops.
ValueVector nestResults;
@@ -800,8 +800,8 @@ mlir::scf::replaceAndCastForOpIterArg(RewriterBase &rewriter, scf::ForOp forOp,
}
// 2. Create the new forOp shell.
- scf::ForOp newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
+ scf::ForOp newForOp = scf::ForOp::create(
+ rewriter, forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
forOp.getStep(), newIterOperands);
newForOp->setAttrs(forOp->getAttrs());
Block &newBlock = newForOp.getRegion().front();
@@ -830,7 +830,7 @@ mlir::scf::replaceAndCastForOpIterArg(RewriterBase &rewriter, scf::ForOp forOp,
clonedYieldOp.getOperand(yieldIdx));
SmallVector<Value> newYieldOperands = clonedYieldOp.getOperands();
newYieldOperands[yieldIdx] = castOut;
- rewriter.create<scf::YieldOp>(newForOp.getLoc(), newYieldOperands);
+ scf::YieldOp::create(rewriter, newForOp.getLoc(), newYieldOperands);
rewriter.eraseOp(clonedYieldOp);
// 6. Inject an outgoing cast op after the forOp.
@@ -925,9 +925,9 @@ struct ForOpIterArgsFolder : public OpRewritePattern<scf::ForOp> {
if (!canonicalize)
return failure();
- scf::ForOp newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
- forOp.getStep(), newIterArgs);
+ scf::ForOp newForOp =
+ scf::ForOp::create(rewriter, forOp.getLoc(), forOp.getLowerBound(),
+ forOp.getUpperBound(), forOp.getStep(), newIterArgs);
newForOp->setAttrs(forOp->getAttrs());
Block &newBlock = newForOp.getRegion().front();
@@ -969,8 +969,8 @@ struct ForOpIterArgsFolder : public OpRewritePattern<scf::ForOp> {
for (unsigned idx = 0, e = keepMask.size(); idx < e; ++idx)
if (keepMask[idx])
filteredOperands.push_back(mergedTerminator.getOperand(idx));
- rewriter.create<scf::YieldOp>(mergedTerminator.getLoc(),
- filteredOperands);
+ scf::YieldOp::create(rewriter, mergedTerminator.getLoc(),
+ filteredOperands);
};
rewriter.mergeBlocks(&oldBlock, &newBlock, newBlockTransferArgs);
@@ -1110,7 +1110,7 @@ struct ForOpTensorCastFolder : public OpRewritePattern<ForOp> {
op, replaceAndCastForOpIterArg(
rewriter, op, iterOpOperand, incomingCast.getSource(),
[](OpBuilder &b, Location loc, Type type, Value source) {
- return b.create<tensor::CastOp>(loc, type, source);
+ return tensor::CastOp::create(b, loc, type, source);
}));
return success();
}
@@ -1684,8 +1684,8 @@ struct ForallOpIterArgsFolder : public OpRewritePattern<ForallOp> {
// Step 3. Create a new scf.forall op with the new shared_outs' operands
// fetched earlier
- auto newForallOp = rewriter.create<scf::ForallOp>(
- forallOp.getLoc(), forallOp.getMixedLowerBound(),
+ auto newForallOp = scf::ForallOp::create(
+ rewriter, forallOp.getLoc(), forallOp.getMixedLowerBound(),
forallOp.getMixedUpperBound(), forallOp.getMixedStep(), newOuts,
forallOp.getMapping(),
/*bodyBuilderFn =*/[](OpBuilder &, Location, ValueRange) {});
@@ -1781,9 +1781,9 @@ struct ForallOpSingleOrZeroIterationDimsFolder
// Replace the loop by a lower-dimensional loop.
ForallOp newOp;
- newOp = rewriter.create<ForallOp>(loc, newMixedLowerBounds,
- newMixedUpperBounds, newMixedSteps,
- op.getOutputs(), std::nullopt, nullptr);
+ newOp = ForallOp::create(rewriter, loc, newMixedLowerBounds,
+ newMixedUpperBounds, newMixedSteps,
+ op.getOutputs(), std::nullopt, nullptr);
newOp.getBodyRegion().getBlocks().clear();
// The new loop needs to keep all attributes from the old one, except for
// "operandSegmentSizes" and static loop bound attributes which capture
@@ -1866,16 +1866,17 @@ struct FoldTensorCastOfOutputIntoForallOp
// Create new loop.
Location loc = forallOp.getLoc();
- auto newForallOp = rewriter.create<ForallOp>(
- loc, forallOp.getMixedLowerBound(), forallOp.getMixedUpperBound(),
- forallOp.getMixedStep(), newOutputTensors, forallOp.getMapping(),
+ auto newForallOp = ForallOp::create(
+ rewriter, loc, forallOp.getMixedLowerBound(),
+ forallOp.getMixedUpperBound(), forallOp.getMixedStep(),
+ newOutputTensors, forallOp.getMapping(),
[&](OpBuilder nestedBuilder, Location nestedLoc, ValueRange bbArgs) {
auto castBlockArgs =
llvm::to_vector(bbArgs.take_back(forallOp->getNumResults()));
for (auto [index, cast] : tensorCastProducers) {
Value &oldTypeBBArg = castBlockArgs[index];
- oldTypeBBArg = nestedBuilder.create<tensor::CastOp>(
- nestedLoc, cast.dstType, oldTypeBBArg);
+ oldTypeBBArg = tensor::CastOp::create(nestedBuilder, nestedLoc,
+ cast.dstType, oldTypeBBArg);
}
// Move old body into new parallel loop.
@@ -1901,8 +1902,8 @@ struct FoldTensorCastOfOutputIntoForallOp
SmallVector<Value> castResults = newForallOp.getResults();
for (auto &item : tensorCastProducers) {
Value &oldTypeResult = castResults[item.first];
- oldTypeResult = rewriter.create<tensor::CastOp>(loc, item.second.dstType,
- oldTypeResult);
+ oldTypeResult = tensor::CastOp::create(rewriter, loc, item.second.dstType,
+ oldTypeResult);
}
rewriter.replaceOp(forallOp, castResults);
return success();
@@ -2310,7 +2311,7 @@ struct RemoveUnusedResults : public OpRewritePattern<IfOp> {
// Create a replacement operation with empty then and else regions.
auto newOp =
- rewriter.create<IfOp>(op.getLoc(), newTypes, op.getCondition());
+ IfOp::create(rewriter, op.getLoc(), newTypes, op.getCondition());
rewriter.createBlock(&newOp.getThenRegion());
rewriter.createBlock(&newOp.getElseRegion());
@@ -2373,8 +2374,8 @@ struct ConvertTrivialIfToSelect : public OpRewritePattern<IfOp> {
if (nonHoistable.size() == op->getNumResults())
return failure();
- IfOp replacement = rewriter.create<IfOp>(op.getLoc(), nonHoistable, cond,
- /*withElseRegion=*/false);
+ IfOp replacement = IfOp::create(rewriter, op.getLoc(), nonHoistable, cond,
+ /*withElseRegion=*/false);
if (replacement.thenBlock())
rewriter.eraseBlock(replacement.thenBlock());
replacement.getThenRegion().takeBody(op.getThenRegion());
@@ -2399,8 +2400,8 @@ struct ConvertTrivialIfToSelect : public OpRewritePattern<IfOp> {
} else if (trueVal == falseVal)
results[it.index()] = trueVal;
else
- results[it.index()] = rewriter.create<arith::SelectOp>(
- op.getLoc(), cond, trueVal, falseVal);
+ results[it.index()] = arith::SelectOp::create(rewriter, op.getLoc(),
+ cond, trueVal, falseVal);
}
rewriter.setInsertionPointToEnd(replacement.thenBlock());
@@ -2489,8 +2490,8 @@ struct ReplaceIfYieldWithConditionOrValue : public OpRewritePattern<IfOp> {
if (!trueVal && falseVal) {
if (!opResult.use_empty()) {
Dialect *constDialect = trueResult.getDefiningOp()->getDialect();
- Value notCond = rewriter.create<arith::XOrIOp>(
- op.getLoc(), op.getCondition(),
+ Value notCond = arith::XOrIOp::create(
+ rewriter, op.getLoc(), op.getCondition(),
constDialect
->materializeConstant(rewriter,
rewriter.getIntegerAttr(i1Ty, 1), i1Ty,
@@ -2603,8 +2604,8 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
SmallVector<Type> mergedTypes(prevIf.getResultTypes());
llvm::append_range(mergedTypes, nextIf.getResultTypes());
- IfOp combinedIf = rewriter.create<IfOp>(
- nextIf.getLoc(), mergedTypes, prevIf.getCondition(), /*hasElse=*/false);
+ IfOp combinedIf = IfOp::create(rewriter, nextIf.getLoc(), mergedTypes,
+ prevIf.getCondition(), /*hasElse=*/false);
rewriter.eraseBlock(&combinedIf.getThenRegion().back());
rewriter.inlineRegionBefore(prevIf.getThenRegion(),
@@ -2619,7 +2620,7 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
SmallVector<Value> mergedYields(thenYield.getOperands());
llvm::append_range(mergedYields, thenYield2.getOperands());
- rewriter.create<YieldOp>(thenYield2.getLoc(), mergedYields);
+ YieldOp::create(rewriter, thenYield2.getLoc(), mergedYields);
rewriter.eraseOp(thenYield);
rewriter.eraseOp(thenYield2);
}
@@ -2643,7 +2644,7 @@ struct CombineIfs : public OpRewritePattern<IfOp> {
SmallVector<Value> mergedElseYields(elseYield.getOperands());
llvm::append_range(mergedElseYields, elseYield2.getOperands());
- rewriter.create<YieldOp>(elseYield2.getLoc(), mergedElseYields);
+ YieldOp::create(rewriter, elseYield2.getLoc(), mergedElseYields);
rewriter.eraseOp(elseYield);
rewriter.eraseOp(elseYield2);
}
@@ -2765,9 +2766,9 @@ struct CombineNestedIfs : public OpRewritePattern<IfOp> {
}
Location loc = op.getLoc();
- Value newCondition = rewriter.create<arith::AndIOp>(
- loc, op.getCondition(), nestedIf.getCondition());
- auto newIf = rewriter.create<IfOp>(loc, op.getResultTypes(), newCondition);
+ Value newCondition = arith::AndIOp::create(rewriter, loc, op.getCondition(),
+ nestedIf.getCondition());
+ auto newIf = IfOp::create(rewriter, loc, op.getResultTypes(), newCondition);
Block *newIfBlock = rewriter.createBlock(&newIf.getThenRegion());
SmallVector<Value> results;
@@ -2775,8 +2776,9 @@ struct CombineNestedIfs : public OpRewritePattern<IfOp> {
rewriter.setInsertionPoint(newIf);
for (auto idx : elseYieldsToUpgradeToSelect)
- results[idx] = rewriter.create<arith::SelectOp>(
- op.getLoc(), op.getCondition(), thenYield[idx], elseYield[idx]);
+ results[idx] =
+ arith::SelectOp::create(rewriter, op.getLoc(), op.getCondition(),
+ thenYield[idx], elseYield[idx]);
rewriter.mergeBlocks(nestedIf.thenBlock(), newIfBlock);
rewriter.setInsertionPointToEnd(newIf.thenBlock());
@@ -2784,7 +2786,7 @@ struct CombineNestedIfs : public OpRewritePattern<IfOp> {
if (!elseYield.empty()) {
rewriter.createBlock(&newIf.getElseRegion());
rewriter.setInsertionPointToEnd(newIf.elseBlock());
- rewriter.create<YieldOp>(loc, elseYield);
+ YieldOp::create(rewriter, loc, elseYield);
}
rewriter.replaceOp(op, results);
return success();
@@ -3101,8 +3103,8 @@ struct ParallelOpSingleOrZeroIterationDimsFolder
}
// Replace the parallel loop by lower-dimensional parallel loop.
auto newOp =
- rewriter.create<ParallelOp>(op.getLoc(), newLowerBounds, newUpperBounds,
- newSteps, op.getInitVals(), nullptr);
+ ParallelOp::create(rewriter, op.getLoc(), newLowerBounds,
+ newUpperBounds, newSteps, op.getInitVals(), nullptr);
// Erase the empty block that was inserted by the builder.
rewriter.eraseBlock(newOp.getBody());
// Clone the loop body and remap the block arguments of the collapsed loops
@@ -3482,8 +3484,8 @@ struct WhileConditionTruth : public OpRewritePattern<WhileOp> {
if (std::get<0>(yieldedAndBlockArgs) == term.getCondition()) {
if (!std::get<1>(yieldedAndBlockArgs).use_empty()) {
if (!constantTrue)
- constantTrue = rewriter.create<arith::ConstantOp>(
- op.getLoc(), term.getCondition().getType(),
+ constantTrue = arith::ConstantOp::create(
+ rewriter, op.getLoc(), term.getCondition().getType(),
rewriter.getBoolAttr(true));
rewriter.replaceAllUsesWith(std::get<1>(yieldedAndBlockArgs),
@@ -3625,8 +3627,8 @@ struct RemoveLoopInvariantArgsFromBeforeBlock
rewriter.replaceOpWithNewOp<YieldOp>(yieldOp, newYieldOpArgs);
}
- auto newWhile =
- rewriter.create<WhileOp>(op.getLoc(), op.getResultTypes(), newInitArgs);
+ auto newWhile = WhileOp::create(rewriter, op.getLoc(), op.getResultTypes(),
+ newInitArgs);
Block &newBeforeBlock = *rewriter.createBlock(
&newWhile.getBefore(), /*insertPt*/ {},
@@ -3748,8 +3750,8 @@ struct RemoveLoopInvariantValueYielded : public OpRewritePattern<WhileOp> {
newCondOpArgs);
}
- auto newWhile = rewriter.create<WhileOp>(op.getLoc(), newAfterBlockType,
- op.getOperands());
+ auto newWhile = WhileOp::create(rewriter, op.getLoc(), newAfterBlockType,
+ op.getOperands());
Block &newAfterBlock =
*rewriter.createBlock(&newWhile.getAfter(), /*insertPt*/ {},
@@ -3855,7 +3857,7 @@ struct WhileUnusedResult : public OpRewritePattern<WhileOp> {
}
auto newWhile =
- rewriter.create<WhileOp>(op.getLoc(), newResultTypes, op.getInits());
+ WhileOp::create(rewriter, op.getLoc(), newResultTypes, op.getInits());
Block &newAfterBlock = *rewriter.createBlock(
&newWhile.getAfter(), /*insertPt*/ {}, newResultTypes, newArgLocs);
@@ -3984,8 +3986,8 @@ struct WhileRemoveUnusedArgs : public OpRewritePattern<WhileOp> {
Location loc = op.getLoc();
auto newWhileOp =
- rewriter.create<WhileOp>(loc, op.getResultTypes(), newInits,
- /*beforeBody*/ nullptr, /*afterBody*/ nullptr);
+ WhileOp::create(rewriter, loc, op.getResultTypes(), newInits,
+ /*beforeBody*/ nullptr, /*afterBody*/ nullptr);
Block &newBeforeBlock = *newWhileOp.getBeforeBody();
Block &newAfterBlock = *newWhileOp.getAfterBody();
@@ -4032,9 +4034,10 @@ struct WhileRemoveDuplicatedResults : public OpRewritePattern<WhileOp> {
ValueRange argsRange(newArgs);
Location loc = op.getLoc();
- auto newWhileOp = rewriter.create<scf::WhileOp>(
- loc, argsRange.getTypes(), op.getInits(), /*beforeBody*/ nullptr,
- /*afterBody*/ nullptr);
+ auto newWhileOp =
+ scf::WhileOp::create(rewriter, loc, argsRange.getTypes(), op.getInits(),
+ /*beforeBody*/ nullptr,
+ /*afterBody*/ nullptr);
Block &newBeforeBlock = *newWhileOp.getBeforeBody();
Block &newAfterBlock = *newWhileOp.getAfterBody();
@@ -4128,8 +4131,8 @@ struct WhileOpAlignBeforeArgs : public OpRewritePattern<WhileOp> {
for (auto &&[i, j] : llvm::enumerate(*mapping))
newResultTypes[j] = loop.getResult(i).getType();
- auto newLoop = rewriter.create<WhileOp>(
- loop.getLoc(), newResultTypes, loop.getInits(),
+ auto newLoop = WhileOp::create(
+ rewriter, loop.getLoc(), newResultTypes, loop.getInits(),
/*beforeBuilder=*/nullptr, /*afterBuilder=*/nullptr);
auto newBefore = newLoop.getBeforeBody();
auto newAfter = newLoop.getAfterBody();
diff --git a/mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp b/mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp
index 9a68565450774..aea842dc59a39 100644
--- a/mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp
+++ b/mlir/lib/Dialect/SCF/TransformOps/SCFTransformOps.cpp
@@ -160,7 +160,7 @@ static scf::ExecuteRegionOp wrapInExecuteRegion(RewriterBase &b,
OpBuilder::InsertionGuard g(b);
b.setInsertionPoint(op);
scf::ExecuteRegionOp executeRegionOp =
- b.create<scf::ExecuteRegionOp>(op->getLoc(), op->getResultTypes());
+ scf::ExecuteRegionOp::create(b, op->getLoc(), op->getResultTypes());
{
OpBuilder::InsertionGuard g(b);
b.setInsertionPointToStart(&executeRegionOp.getRegion().emplaceBlock());
@@ -169,7 +169,7 @@ static scf::ExecuteRegionOp wrapInExecuteRegion(RewriterBase &b,
assert(clonedRegion.empty() && "expected empty region");
b.inlineRegionBefore(op->getRegions().front(), clonedRegion,
clonedRegion.end());
- b.create<scf::YieldOp>(op->getLoc(), clonedOp->getResults());
+ scf::YieldOp::create(b, op->getLoc(), clonedOp->getResults());
}
b.replaceOp(op, executeRegionOp.getResults());
return executeRegionOp;
diff --git a/mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp b/mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp
index 85093828efa96..64c4d607e3fb9 100644
--- a/mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/BufferizableOpInterfaceImpl.cpp
@@ -41,7 +41,7 @@ static Value castBuffer(OpBuilder &b, Value buffer, Type type) {
// iter_arg's layout map must be changed (see uses of `castBuffer`).
assert(memref::CastOp::areCastCompatible(buffer.getType(), type) &&
"scf.while op bufferization: cast incompatible");
- return b.create<memref::CastOp>(buffer.getLoc(), type, buffer).getResult();
+ return memref::CastOp::create(b, buffer.getLoc(), type, buffer).getResult();
}
/// Helper function for loop bufferization. Return "true" if the given value
@@ -189,7 +189,7 @@ struct ExecuteRegionOpInterface
// Create new op and move over region.
auto newOp =
- rewriter.create<scf::ExecuteRegionOp>(op->getLoc(), newResultTypes);
+ scf::ExecuteRegionOp::create(rewriter, op->getLoc(), newResultTypes);
newOp.getRegion().takeBody(executeRegionOp.getRegion());
// Bufferize every block.
@@ -203,8 +203,8 @@ struct ExecuteRegionOpInterface
SmallVector<Value> newResults;
for (const auto &it : llvm::enumerate(executeRegionOp->getResultTypes())) {
if (isa<TensorType>(it.value())) {
- newResults.push_back(rewriter.create<bufferization::ToTensorOp>(
- executeRegionOp.getLoc(), it.value(),
+ newResults.push_back(bufferization::ToTensorOp::create(
+ rewriter, executeRegionOp.getLoc(), it.value(),
newOp->getResult(it.index())));
} else {
newResults.push_back(newOp->getResult(it.index()));
@@ -258,9 +258,9 @@ struct IfOpInterface
// Create new op.
rewriter.setInsertionPoint(ifOp);
- auto newIfOp =
- rewriter.create<scf::IfOp>(ifOp.getLoc(), newTypes, ifOp.getCondition(),
- /*withElseRegion=*/true);
+ auto newIfOp = scf::IfOp::create(rewriter, ifOp.getLoc(), newTypes,
+ ifOp.getCondition(),
+ /*withElseRegion=*/true);
// Move over then/else blocks.
rewriter.mergeBlocks(ifOp.thenBlock(), newIfOp.thenBlock());
@@ -372,9 +372,9 @@ struct IndexSwitchOpInterface
// Create new op.
rewriter.setInsertionPoint(switchOp);
- auto newSwitchOp = rewriter.create<scf::IndexSwitchOp>(
- switchOp.getLoc(), newTypes, switchOp.getArg(), switchOp.getCases(),
- switchOp.getCases().size());
+ auto newSwitchOp = scf::IndexSwitchOp::create(
+ rewriter, switchOp.getLoc(), newTypes, switchOp.getArg(),
+ switchOp.getCases(), switchOp.getCases().size());
// Move over blocks.
for (auto [src, dest] :
@@ -767,8 +767,8 @@ struct ForOpInterface
}
// Construct a new scf.for op with memref instead of tensor values.
- auto newForOp = rewriter.create<scf::ForOp>(
- forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
+ auto newForOp = scf::ForOp::create(
+ rewriter, forOp.getLoc(), forOp.getLowerBound(), forOp.getUpperBound(),
forOp.getStep(), castedInitArgs);
newForOp->setAttrs(forOp->getAttrs());
Block *loopBody = newForOp.getBody();
@@ -1003,8 +1003,8 @@ struct WhileOpInterface
// Construct a new scf.while op with memref instead of tensor values.
ValueRange argsRangeBefore(castedInitArgs);
TypeRange argsTypesBefore(argsRangeBefore);
- auto newWhileOp = rewriter.create<scf::WhileOp>(
- whileOp.getLoc(), argsTypesAfter, castedInitArgs);
+ auto newWhileOp = scf::WhileOp::create(rewriter, whileOp.getLoc(),
+ argsTypesAfter, castedInitArgs);
// Add before/after regions to the new op.
SmallVector<Location> bbArgLocsBefore(castedInitArgs.size(),
@@ -1263,8 +1263,8 @@ struct ForallOpInterface
forallOp.getBody()->getArguments().drop_front(rank), buffers)) {
BlockArgument bbArg = std::get<0>(it);
Value buffer = std::get<1>(it);
- Value bufferAsTensor = rewriter.create<ToTensorOp>(
- forallOp.getLoc(), bbArg.getType(), buffer);
+ Value bufferAsTensor = ToTensorOp::create(rewriter, forallOp.getLoc(),
+ bbArg.getType(), buffer);
bbArg.replaceAllUsesWith(bufferAsTensor);
}
@@ -1272,8 +1272,8 @@ struct ForallOpInterface
// introduced terminator.
rewriter.setInsertionPoint(forallOp);
ForallOp newForallOp;
- newForallOp = rewriter.create<ForallOp>(
- forallOp.getLoc(), forallOp.getMixedLowerBound(),
+ newForallOp = ForallOp::create(
+ rewriter, forallOp.getLoc(), forallOp.getMixedLowerBound(),
forallOp.getMixedUpperBound(), forallOp.getMixedStep(),
/*outputs=*/ValueRange(), forallOp.getMapping());
diff --git a/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp b/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
index 3e93dc80b18ec..bee77800e9d44 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp
@@ -50,19 +50,19 @@ struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
SmallVector<Value> initArgs;
initArgs.push_back(forOp.getLowerBound());
llvm::append_range(initArgs, forOp.getInitArgs());
- auto whileOp = rewriter.create<WhileOp>(forOp.getLoc(), lcvTypes, initArgs,
- forOp->getAttrs());
+ auto whileOp = WhileOp::create(rewriter, 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.getBefore(), whileOp.getBefore().begin(), lcvTypes, lcvLocs);
rewriter.setInsertionPointToStart(whileOp.getBeforeBody());
- auto cmpOp = rewriter.create<arith::CmpIOp>(
- whileOp.getLoc(), arith::CmpIPredicate::slt,
+ auto cmpOp = arith::CmpIOp::create(
+ rewriter, whileOp.getLoc(), arith::CmpIPredicate::slt,
beforeBlock->getArgument(0), forOp.getUpperBound());
- rewriter.create<scf::ConditionOp>(whileOp.getLoc(), cmpOp.getResult(),
- beforeBlock->getArguments());
+ scf::ConditionOp::create(rewriter, whileOp.getLoc(), cmpOp.getResult(),
+ beforeBlock->getArguments());
// Inline for-loop body into an executeRegion operation in the "after"
// region. The return type of the execRegionOp does not contain the
@@ -72,8 +72,9 @@ struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
// Add induction variable incrementation
rewriter.setInsertionPointToEnd(afterBlock);
- auto ivIncOp = rewriter.create<arith::AddIOp>(
- whileOp.getLoc(), afterBlock->getArgument(0), forOp.getStep());
+ auto ivIncOp =
+ arith::AddIOp::create(rewriter, 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/ForallToParallel.cpp b/mlir/lib/Dialect/SCF/Transforms/ForallToParallel.cpp
index 44e6840b03a3d..b95604fa44cb9 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ForallToParallel.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ForallToParallel.cpp
@@ -40,7 +40,7 @@ LogicalResult mlir::scf::forallToParallelLoop(RewriterBase &rewriter,
SmallVector<Value> steps = forallOp.getStep(rewriter);
// Create empty scf.parallel op.
- auto parallelOp = rewriter.create<scf::ParallelOp>(loc, lbs, ubs, steps);
+ auto parallelOp = scf::ParallelOp::create(rewriter, loc, lbs, ubs, steps);
rewriter.eraseBlock(¶llelOp.getRegion().front());
rewriter.inlineRegionBefore(forallOp.getRegion(), parallelOp.getRegion(),
parallelOp.getRegion().begin());
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
index bcecef5e6e0a9..59828563a8196 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopPipelining.cpp
@@ -279,25 +279,25 @@ LogicalResult LoopPipelinerInternal::emitPrologue(RewriterBase &rewriter) {
if (dynamicLoop) {
Type t = ub.getType();
// pred = ub > lb + (i * step)
- Value iv = rewriter.create<arith::AddIOp>(
- loc, lb,
- rewriter.create<arith::MulIOp>(
- loc, step,
- rewriter.create<arith::ConstantOp>(
- loc, rewriter.getIntegerAttr(t, i))));
- predicates[i] = rewriter.create<arith::CmpIOp>(
- loc, arith::CmpIPredicate::slt, iv, ub);
+ Value iv = arith::AddIOp::create(
+ rewriter, loc, lb,
+ arith::MulIOp::create(
+ rewriter, loc, step,
+ arith::ConstantOp::create(rewriter, loc,
+ rewriter.getIntegerAttr(t, i))));
+ predicates[i] = arith::CmpIOp::create(rewriter, loc,
+ arith::CmpIPredicate::slt, iv, ub);
}
// special handling for induction variable as the increment is implicit.
// iv = lb + i * step
Type t = lb.getType();
- Value iv = rewriter.create<arith::AddIOp>(
- loc, lb,
- rewriter.create<arith::MulIOp>(
- loc, step,
- rewriter.create<arith::ConstantOp>(loc,
- rewriter.getIntegerAttr(t, i))));
+ Value iv = arith::AddIOp::create(
+ rewriter, loc, lb,
+ arith::MulIOp::create(
+ rewriter, loc, step,
+ arith::ConstantOp::create(rewriter, loc,
+ rewriter.getIntegerAttr(t, i))));
setValueMapping(forOp.getInductionVar(), iv, i);
for (Operation *op : opOrder) {
if (stages[op] > i)
@@ -332,8 +332,8 @@ LogicalResult LoopPipelinerInternal::emitPrologue(RewriterBase &rewriter) {
Value prevValue = valueMapping
[forOp.getRegionIterArgs()[operand.getOperandNumber()]]
[i - stages[op]];
- source = rewriter.create<arith::SelectOp>(
- loc, predicates[predicateIdx], source, prevValue);
+ source = arith::SelectOp::create(
+ rewriter, loc, predicates[predicateIdx], source, prevValue);
}
setValueMapping(forOp.getRegionIterArgs()[operand.getOperandNumber()],
source, i - stages[op] + 1);
@@ -444,15 +444,15 @@ scf::ForOp LoopPipelinerInternal::createKernelLoop(
Type t = ub.getType();
Location loc = forOp.getLoc();
// newUb = ub - maxStage * step
- Value maxStageValue = rewriter.create<arith::ConstantOp>(
- loc, rewriter.getIntegerAttr(t, maxStage));
+ Value maxStageValue = arith::ConstantOp::create(
+ rewriter, loc, rewriter.getIntegerAttr(t, maxStage));
Value maxStageByStep =
- rewriter.create<arith::MulIOp>(loc, step, maxStageValue);
- newUb = rewriter.create<arith::SubIOp>(loc, ub, maxStageByStep);
+ arith::MulIOp::create(rewriter, loc, step, maxStageValue);
+ newUb = arith::SubIOp::create(rewriter, loc, ub, maxStageByStep);
}
auto newForOp =
- rewriter.create<scf::ForOp>(forOp.getLoc(), forOp.getLowerBound(), newUb,
- forOp.getStep(), newLoopArg);
+ scf::ForOp::create(rewriter, forOp.getLoc(), forOp.getLowerBound(), newUb,
+ forOp.getStep(), newLoopArg);
// When there are no iter args, the loop body terminator will be created.
// Since we always create it below, remove the terminator if it was created.
if (!newForOp.getBody()->empty())
@@ -483,16 +483,17 @@ LogicalResult LoopPipelinerInternal::createKernel(
Type t = ub.getType();
for (unsigned i = 0; i < maxStage; i++) {
// c = ub - (maxStage - i) * step
- Value c = rewriter.create<arith::SubIOp>(
- loc, ub,
- rewriter.create<arith::MulIOp>(
- loc, step,
- rewriter.create<arith::ConstantOp>(
- loc, rewriter.getIntegerAttr(t, int64_t(maxStage - i)))));
-
- Value pred = rewriter.create<arith::CmpIOp>(
- newForOp.getLoc(), arith::CmpIPredicate::slt,
- newForOp.getInductionVar(), c);
+ Value c = arith::SubIOp::create(
+ rewriter, loc, ub,
+ arith::MulIOp::create(
+ rewriter, loc, step,
+ arith::ConstantOp::create(
+ rewriter, loc,
+ rewriter.getIntegerAttr(t, int64_t(maxStage - i)))));
+
+ Value pred = arith::CmpIOp::create(rewriter, newForOp.getLoc(),
+ arith::CmpIPredicate::slt,
+ newForOp.getInductionVar(), c);
predicates[i] = pred;
}
}
@@ -515,13 +516,13 @@ LogicalResult LoopPipelinerInternal::createKernel(
// offset = (maxStage - stages[op]) * step
Type t = step.getType();
- Value offset = rewriter.create<arith::MulIOp>(
- forOp.getLoc(), step,
- rewriter.create<arith::ConstantOp>(
- forOp.getLoc(),
+ Value offset = arith::MulIOp::create(
+ rewriter, forOp.getLoc(), step,
+ arith::ConstantOp::create(
+ rewriter, forOp.getLoc(),
rewriter.getIntegerAttr(t, maxStage - stages[op])));
- Value iv = rewriter.create<arith::AddIOp>(
- forOp.getLoc(), newForOp.getInductionVar(), offset);
+ Value iv = arith::AddIOp::create(rewriter, forOp.getLoc(),
+ newForOp.getInductionVar(), offset);
nestedNewOp->setOperand(operand->getOperandNumber(), iv);
rewriter.setInsertionPointAfter(newOp);
continue;
@@ -594,8 +595,8 @@ LogicalResult LoopPipelinerInternal::createKernel(
auto defStage = stages.find(def);
if (defStage != stages.end() && defStage->second < maxStage) {
Value pred = predicates[defStage->second];
- source = rewriter.create<arith::SelectOp>(
- pred.getLoc(), pred, source,
+ source = arith::SelectOp::create(
+ rewriter, pred.getLoc(), pred, source,
newForOp.getBody()
->getArguments()[yieldOperand.getOperandNumber() + 1]);
}
@@ -638,7 +639,7 @@ LogicalResult LoopPipelinerInternal::createKernel(
maxStage - defStage->second + 1);
}
}
- rewriter.create<scf::YieldOp>(forOp.getLoc(), yieldOperands);
+ scf::YieldOp::create(rewriter, forOp.getLoc(), yieldOperands);
return success();
}
@@ -652,8 +653,8 @@ LoopPipelinerInternal::emitEpilogue(RewriterBase &rewriter,
// removed by dead code if not used.
auto createConst = [&](int v) {
- return rewriter.create<arith::ConstantOp>(loc,
- rewriter.getIntegerAttr(t, v));
+ return arith::ConstantOp::create(rewriter, loc,
+ rewriter.getIntegerAttr(t, v));
};
// total_iterations = cdiv(range_
diff , step);
@@ -661,42 +662,44 @@ LoopPipelinerInternal::emitEpilogue(RewriterBase &rewriter,
// - total_iterations = (range_
diff + step + (step < 0 ? 1 : -1)) / step
Value zero = createConst(0);
Value one = createConst(1);
- Value stepLessZero = rewriter.create<arith::CmpIOp>(
- loc, arith::CmpIPredicate::slt, step, zero);
- Value stepDecr =
- rewriter.create<arith::SelectOp>(loc, stepLessZero, one, createConst(-1));
+ Value stepLessZero = arith::CmpIOp::create(
+ rewriter, loc, arith::CmpIPredicate::slt, step, zero);
+ Value stepDecr = arith::SelectOp::create(rewriter, loc, stepLessZero, one,
+ createConst(-1));
- Value rangeDiff = rewriter.create<arith::SubIOp>(loc, ub, lb);
- Value rangeIncrStep = rewriter.create<arith::AddIOp>(loc, rangeDiff, step);
+ Value rangeDiff = arith::SubIOp::create(rewriter, loc, ub, lb);
+ Value rangeIncrStep = arith::AddIOp::create(rewriter, loc, rangeDiff, step);
Value rangeDecr =
- rewriter.create<arith::AddIOp>(loc, rangeIncrStep, stepDecr);
- Value totalIterations = rewriter.create<arith::DivSIOp>(loc, rangeDecr, step);
+ arith::AddIOp::create(rewriter, loc, rangeIncrStep, stepDecr);
+ Value totalIterations =
+ arith::DivSIOp::create(rewriter, loc, rangeDecr, step);
// If total_iters < max_stage, start the epilogue at zero to match the
// ramp-up in the prologue.
// start_iter = max(0, total_iters - max_stage)
- Value iterI = rewriter.create<arith::SubIOp>(loc, totalIterations,
- createConst(maxStage));
- iterI = rewriter.create<arith::MaxSIOp>(loc, zero, iterI);
+ Value iterI = arith::SubIOp::create(rewriter, loc, totalIterations,
+ createConst(maxStage));
+ iterI = arith::MaxSIOp::create(rewriter, loc, zero, iterI);
// Capture predicates for dynamic loops.
SmallVector<Value> predicates(maxStage + 1);
for (int64_t i = 1; i <= maxStage; i++) {
// newLastIter = lb + step * iterI
- Value newlastIter = rewriter.create<arith::AddIOp>(
- loc, lb, rewriter.create<arith::MulIOp>(loc, step, iterI));
+ Value newlastIter = arith::AddIOp::create(
+ rewriter, loc, lb, arith::MulIOp::create(rewriter, loc, step, iterI));
setValueMapping(forOp.getInductionVar(), newlastIter, i);
// increment to next iterI
- iterI = rewriter.create<arith::AddIOp>(loc, iterI, one);
+ iterI = arith::AddIOp::create(rewriter, loc, iterI, one);
if (dynamicLoop) {
// Disable stages when `i` is greater than total_iters.
// pred = total_iters >= i
- predicates[i] = rewriter.create<arith::CmpIOp>(
- loc, arith::CmpIPredicate::sge, totalIterations, createConst(i));
+ predicates[i] =
+ arith::CmpIOp::create(rewriter, loc, arith::CmpIPredicate::sge,
+ totalIterations, createConst(i));
}
}
@@ -758,8 +761,8 @@ LoopPipelinerInternal::emitEpilogue(RewriterBase &rewriter,
unsigned nextVersion = currentVersion + 1;
Value pred = predicates[currentVersion];
Value prevValue = valueMapping[mapVal][currentVersion];
- auto selOp = rewriter.create<arith::SelectOp>(loc, pred, pair.value(),
- prevValue);
+ auto selOp = arith::SelectOp::create(rewriter, loc, pred,
+ pair.value(), prevValue);
returnValues[ri] = selOp;
if (nextVersion <= maxStage)
setValueMapping(mapVal, selOp, nextVersion);
diff --git a/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp b/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
index d17cd47b9043a..4752c0837c1c5 100644
--- a/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/LoopSpecialization.cpp
@@ -63,13 +63,13 @@ static void specializeParallelLoopForUnrolling(ParallelOp op) {
Value cond;
for (auto bound : llvm::zip(op.getUpperBound(), constantIndices)) {
Value constant =
- b.create<arith::ConstantIndexOp>(op.getLoc(), std::get<1>(bound));
- Value cmp = b.create<arith::CmpIOp>(op.getLoc(), arith::CmpIPredicate::eq,
- std::get<0>(bound), constant);
- cond = cond ? b.create<arith::AndIOp>(op.getLoc(), cond, cmp) : cmp;
+ arith::ConstantIndexOp::create(b, op.getLoc(), std::get<1>(bound));
+ Value cmp = arith::CmpIOp::create(b, op.getLoc(), arith::CmpIPredicate::eq,
+ std::get<0>(bound), constant);
+ cond = cond ? arith::AndIOp::create(b, op.getLoc(), cond, cmp) : cmp;
map.map(std::get<0>(bound), constant);
}
- auto ifOp = b.create<scf::IfOp>(op.getLoc(), cond, /*withElseRegion=*/true);
+ auto ifOp = scf::IfOp::create(b, op.getLoc(), cond, /*withElseRegion=*/true);
ifOp.getThenBodyBuilder().clone(*op.getOperation(), map);
ifOp.getElseBodyBuilder().clone(*op.getOperation());
op.erase();
@@ -94,11 +94,11 @@ static void specializeForLoopForUnrolling(ForOp op) {
OpBuilder b(op);
IRMapping map;
- Value constant = b.create<arith::ConstantIndexOp>(op.getLoc(), minConstant);
- Value cond = b.create<arith::CmpIOp>(op.getLoc(), arith::CmpIPredicate::eq,
- bound, constant);
+ Value constant = arith::ConstantIndexOp::create(b, op.getLoc(), minConstant);
+ Value cond = arith::CmpIOp::create(b, op.getLoc(), arith::CmpIPredicate::eq,
+ bound, constant);
map.map(bound, constant);
- auto ifOp = b.create<scf::IfOp>(op.getLoc(), cond, /*withElseRegion=*/true);
+ auto ifOp = scf::IfOp::create(b, op.getLoc(), cond, /*withElseRegion=*/true);
ifOp.getThenBodyBuilder().clone(*op.getOperation(), map);
ifOp.getElseBodyBuilder().clone(*op.getOperation());
op.erase();
diff --git a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
index ad1267381c4f2..694cd85435f63 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopFusion.cpp
@@ -190,8 +190,8 @@ static void fuseIfLegal(ParallelOp firstPloop, ParallelOp &secondPloop,
IRRewriter b(builder);
b.setInsertionPoint(secondPloop);
- auto newSecondPloop = b.create<ParallelOp>(
- secondPloop.getLoc(), secondPloop.getLowerBound(),
+ auto newSecondPloop = ParallelOp::create(
+ b, secondPloop.getLoc(), secondPloop.getLowerBound(),
secondPloop.getUpperBound(), secondPloop.getStep(), newInitVars);
Block *newBlock = newSecondPloop.getBody();
@@ -212,7 +212,7 @@ static void fuseIfLegal(ParallelOp firstPloop, ParallelOp &secondPloop,
SmallVector<Value> newReduceArgs(reduceArgs1.begin(), reduceArgs1.end());
newReduceArgs.append(reduceArgs2.begin(), reduceArgs2.end());
- auto newReduceOp = b.create<scf::ReduceOp>(term2.getLoc(), newReduceArgs);
+ auto newReduceOp = scf::ReduceOp::create(b, term2.getLoc(), newReduceArgs);
for (auto &&[i, reg] : llvm::enumerate(llvm::concat<Region>(
term1.getReductions(), term2.getReductions()))) {
diff --git a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
index 66f7bc27f82ff..84a779b90f6c2 100644
--- a/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/ParallelLoopTiling.cpp
@@ -58,28 +58,28 @@ std::pair<ParallelOp, ParallelOp>
mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
bool noMinMaxBounds) {
OpBuilder b(op);
- auto zero = b.create<arith::ConstantIndexOp>(op.getLoc(), 0);
+ auto zero = arith::ConstantIndexOp::create(b, op.getLoc(), 0);
SmallVector<Value, 2> tileSizeConstants;
tileSizeConstants.reserve(op.getUpperBound().size());
for (size_t i = 0, end = op.getUpperBound().size(); i != end; ++i) {
if (i < tileSizes.size())
tileSizeConstants.push_back(
- b.create<arith::ConstantIndexOp>(op.getLoc(), tileSizes[i]));
+ arith::ConstantIndexOp::create(b, op.getLoc(), tileSizes[i]));
else
// Just pick 1 for the remaining dimensions.
tileSizeConstants.push_back(
- b.create<arith::ConstantIndexOp>(op.getLoc(), 1));
+ arith::ConstantIndexOp::create(b, op.getLoc(), 1));
}
// Create the outer loop with adjusted steps.
SmallVector<Value, 2> newSteps;
newSteps.reserve(op.getStep().size());
for (auto step : llvm::zip(op.getStep(), tileSizeConstants)) {
- newSteps.push_back(b.create<arith::MulIOp>(op.getLoc(), std::get<0>(step),
- std::get<1>(step)));
+ newSteps.push_back(arith::MulIOp::create(b, op.getLoc(), std::get<0>(step),
+ std::get<1>(step)));
}
- auto outerLoop = b.create<ParallelOp>(op.getLoc(), op.getLowerBound(),
- op.getUpperBound(), newSteps);
+ auto outerLoop = ParallelOp::create(b, op.getLoc(), op.getLowerBound(),
+ op.getUpperBound(), newSteps);
b.setInsertionPointToStart(outerLoop.getBody());
// Compute min(size, dim - offset) to avoid out-of-bounds accesses.
@@ -130,45 +130,45 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
// Otherwise, we dynamically compute the bound for
// each iteration of the outer loop.
newBounds.push_back(
- b.create<affine::AffineMinOp>(op.getLoc(), b.getIndexType(), minMap,
- ValueRange{newStep, upperBound, iv}));
+ affine::AffineMinOp::create(b, op.getLoc(), b.getIndexType(), minMap,
+ ValueRange{newStep, upperBound, iv}));
}
- auto innerLoop = b.create<ParallelOp>(
- op.getLoc(), SmallVector<Value, 2>(newBounds.size(), zero), newBounds,
+ auto innerLoop = ParallelOp::create(
+ b, op.getLoc(), SmallVector<Value, 2>(newBounds.size(), zero), newBounds,
op.getStep());
if (noMinMaxBounds && needInboundCheck) {
b.setInsertionPointToStart(innerLoop.getBody());
// Insert in-bound check
Value inbound =
- b.create<arith::ConstantIntOp>(op.getLoc(), b.getIntegerType(1), 1);
+ arith::ConstantIntOp::create(b, op.getLoc(), b.getIntegerType(1), 1);
for (auto [outerUpperBound, outerIV, innerIV, innerStep] :
llvm::zip(outerLoop.getUpperBound(), outerLoop.getInductionVars(),
innerLoop.getInductionVars(), innerLoop.getStep())) {
// %in_bound = %in_bound &&
// (%inner_iv * %inner_step + %outer_iv < %outer_upper_bound)
- Value index = b.create<arith::AddIOp>(
- op.getLoc(), b.create<arith::MulIOp>(op.getLoc(), innerIV, innerStep),
- outerIV);
- Value dimInbound = b.create<arith::CmpIOp>(
- op.getLoc(), arith::CmpIPredicate::ult, index, outerUpperBound);
- inbound = b.create<arith::AndIOp>(op.getLoc(), inbound, dimInbound);
+ Value index = arith::AddIOp::create(
+ b, op.getLoc(),
+ arith::MulIOp::create(b, op.getLoc(), innerIV, innerStep), outerIV);
+ Value dimInbound = arith::CmpIOp::create(
+ b, op.getLoc(), arith::CmpIPredicate::ult, index, outerUpperBound);
+ inbound = arith::AndIOp::create(b, op.getLoc(), inbound, dimInbound);
}
- auto ifInbound = b.create<IfOp>(op.getLoc(),
- /*resultTypes*/ ArrayRef<Type>{}, inbound,
- /*hasElseRegion*/ false);
+ auto ifInbound = IfOp::create(b, op.getLoc(),
+ /*resultTypes*/ ArrayRef<Type>{}, inbound,
+ /*hasElseRegion*/ false);
ifInbound.getThenRegion().takeBody(op.getRegion());
Block &thenBlock = ifInbound.getThenRegion().front();
// Replace the scf.reduce terminator with an scf.yield terminator.
Operation *reduceOp = thenBlock.getTerminator();
b.setInsertionPointToEnd(&thenBlock);
- b.create<scf::YieldOp>(reduceOp->getLoc());
+ scf::YieldOp::create(b, reduceOp->getLoc());
reduceOp->erase();
b.setInsertionPointToStart(innerLoop.getBody());
for (const auto &ivs : llvm::enumerate(llvm::zip(
innerLoop.getInductionVars(), outerLoop.getInductionVars()))) {
- auto newIndex = b.create<arith::AddIOp>(
- op.getLoc(), std::get<0>(ivs.value()), std::get<1>(ivs.value()));
+ auto newIndex = arith::AddIOp::create(
+ b, op.getLoc(), std::get<0>(ivs.value()), std::get<1>(ivs.value()));
thenBlock.getArgument(ivs.index())
.replaceAllUsesExcept(newIndex, newIndex);
}
@@ -179,8 +179,8 @@ mlir::scf::tileParallelLoop(ParallelOp op, ArrayRef<int64_t> tileSizes,
for (auto ivs : llvm::zip(innerLoop.getInductionVars(),
outerLoop.getInductionVars())) {
Value innerIndex = std::get<0>(ivs);
- auto newIndex = b.create<arith::AddIOp>(op.getLoc(), std::get<0>(ivs),
- std::get<1>(ivs));
+ auto newIndex = arith::AddIOp::create(b, op.getLoc(), std::get<0>(ivs),
+ std::get<1>(ivs));
innerIndex.replaceAllUsesExcept(newIndex, newIndex);
}
}
diff --git a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
index 09326242eec2a..1b07b77546030 100644
--- a/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/StructuralTypeConversions.cpp
@@ -112,11 +112,11 @@ class ConvertForOpTypes
// We can not do clone as the number of result types after conversion
// might be
diff erent.
- ForOp newOp = rewriter.create<ForOp>(
- op.getLoc(), llvm::getSingleElement(adaptor.getLowerBound()),
- llvm::getSingleElement(adaptor.getUpperBound()),
- llvm::getSingleElement(adaptor.getStep()),
- flattenValues(adaptor.getInitArgs()));
+ ForOp newOp = ForOp::create(rewriter, op.getLoc(),
+ llvm::getSingleElement(adaptor.getLowerBound()),
+ llvm::getSingleElement(adaptor.getUpperBound()),
+ llvm::getSingleElement(adaptor.getStep()),
+ flattenValues(adaptor.getInitArgs()));
// Reserve whatever attributes in the original op.
newOp->setAttrs(op->getAttrs());
@@ -142,9 +142,9 @@ class ConvertIfOpTypes
ConversionPatternRewriter &rewriter,
TypeRange dstTypes) const {
- IfOp newOp = rewriter.create<IfOp>(
- op.getLoc(), dstTypes, llvm::getSingleElement(adaptor.getCondition()),
- true);
+ IfOp newOp =
+ IfOp::create(rewriter, op.getLoc(), dstTypes,
+ llvm::getSingleElement(adaptor.getCondition()), true);
newOp->setAttrs(op->getAttrs());
// We do not need the empty blocks created by rewriter.
@@ -171,8 +171,8 @@ class ConvertWhileOpTypes
std::optional<WhileOp> convertSourceOp(WhileOp op, OneToNOpAdaptor adaptor,
ConversionPatternRewriter &rewriter,
TypeRange dstTypes) const {
- auto newOp = rewriter.create<WhileOp>(op.getLoc(), dstTypes,
- flattenValues(adaptor.getOperands()));
+ auto newOp = WhileOp::create(rewriter, op.getLoc(), dstTypes,
+ flattenValues(adaptor.getOperands()));
for (auto i : {0u, 1u}) {
if (failed(rewriter.convertRegionTypes(&op.getRegion(i), *typeConverter)))
diff --git a/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp b/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp
index 484b03dd715f8..c0e47ee1e74fc 100644
--- a/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp
@@ -447,9 +447,9 @@ static LogicalResult generateLoopNestUsingForOp(
SmallVector<Value> ivs;
for (auto [lb, ub, step] : llvm::zip_equal(lbVals, ubVals, stepVals)) {
auto loop =
- rewriter.create<scf::ForOp>(loc, lb, ub, step, destinationTensors,
- [](OpBuilder &bodyBuilder, Location bodyLoc,
- Value iv, ValueRange /*iterArgs*/) {});
+ scf::ForOp::create(rewriter, loc, lb, ub, step, destinationTensors,
+ [](OpBuilder &bodyBuilder, Location bodyLoc,
+ Value iv, ValueRange /*iterArgs*/) {});
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
rewriter.setInsertionPointToEnd(loop.getBody());
@@ -476,12 +476,12 @@ static LogicalResult generateLoopNestUsingForOp(
resultSizes)) {
SmallVector<OpFoldResult> resultStride(resultOffset.size(),
rewriter.getIndexAttr(1));
- auto insertSlice = rewriter.create<tensor::InsertSliceOp>(
- loc, tiledValue, destinationTensor, resultOffset, resultSize,
+ auto insertSlice = tensor::InsertSliceOp::create(
+ rewriter, loc, tiledValue, destinationTensor, resultOffset, resultSize,
resultStride);
yieldedValues.push_back(insertSlice);
}
- rewriter.create<scf::YieldOp>(loc, yieldedValues);
+ scf::YieldOp::create(rewriter, loc, yieldedValues);
// Add the scf.yield operations for all the outer loops.
for (auto [outerLoop, innerLoop] :
@@ -489,7 +489,7 @@ static LogicalResult generateLoopNestUsingForOp(
MutableArrayRef(loops).drop_front())) {
rewriter.setInsertionPointToEnd(
cast<scf::ForOp>(outerLoop.getOperation()).getBody());
- rewriter.create<scf::YieldOp>(outerLoop.getLoc(), innerLoop->getResults());
+ scf::YieldOp::create(rewriter, outerLoop.getLoc(), innerLoop->getResults());
}
return success();
}
@@ -530,14 +530,14 @@ static LogicalResult generateLoopNestUsingForallOp(
continue;
nonZeroNumThreads.push_back(nt);
}
- forallOp = rewriter.create<scf::ForallOp>(loc, nonZeroNumThreads,
- destinationTensors, mappingAttr);
+ forallOp = scf::ForallOp::create(rewriter, loc, nonZeroNumThreads,
+ destinationTensors, mappingAttr);
} else {
SmallVector<OpFoldResult> lbs, ubs, steps;
std::tie(lbs, ubs, steps) =
getLoopBounds(rewriter, loc, loopRanges, tileSizes);
- forallOp = rewriter.create<scf::ForallOp>(loc, lbs, ubs, steps,
- destinationTensors, mappingAttr);
+ forallOp = scf::ForallOp::create(rewriter, loc, lbs, ubs, steps,
+ destinationTensors, mappingAttr);
}
loops.push_back(forallOp);
@@ -558,9 +558,9 @@ static LogicalResult generateLoopNestUsingForallOp(
SmallVector<OpFoldResult> resultStride(resultOffset.size(),
rewriter.getIndexAttr(1));
- rewriter.create<tensor::ParallelInsertSliceOp>(
- loc, tiledValue, destinationTensor, resultOffset, resultSize,
- resultStride);
+ tensor::ParallelInsertSliceOp::create(rewriter, loc, tiledValue,
+ destinationTensor, resultOffset,
+ resultSize, resultStride);
}
return success();
}
@@ -795,9 +795,9 @@ FailureOr<LoopLikeOpInterface> yieldTiledValuesAndReplaceLoop<scf::ForOp>(
auto inits = llvm::to_vector(loopOp.getInitArgs());
inits.append(newInitOperands.begin(), newInitOperands.end());
- auto newLoop = rewriter.create<scf::ForOp>(
- loc, loopOp.getLowerBound(), loopOp.getUpperBound(), loopOp.getStep(),
- inits, [](OpBuilder &, Location, Value, ValueRange) {});
+ auto newLoop = scf::ForOp::create(
+ rewriter, loc, loopOp.getLowerBound(), loopOp.getUpperBound(),
+ loopOp.getStep(), inits, [](OpBuilder &, Location, Value, ValueRange) {});
// Move the loop body to the new op.
Block *loopBody = loopOp.getBody();
@@ -826,9 +826,9 @@ FailureOr<LoopLikeOpInterface> yieldTiledValuesAndReplaceLoop<scf::ForOp>(
resultSizes)) {
SmallVector<OpFoldResult> resultStride(resultOffset.size(),
rewriter.getIndexAttr(1));
- Value insert = rewriter.create<tensor::InsertSliceOp>(
- yieldOp->getLoc(), tiledValue, regionIterArg, resultOffset, resultSize,
- resultStride);
+ Value insert = tensor::InsertSliceOp::create(
+ rewriter, yieldOp->getLoc(), tiledValue, regionIterArg, resultOffset,
+ resultSize, resultStride);
newYieldValues.push_back(insert);
}
@@ -848,8 +848,8 @@ FailureOr<LoopLikeOpInterface> yieldTiledValuesAndReplaceLoop<scf::ForallOp>(
rewriter.setInsertionPoint(loopOp);
auto inits = llvm::to_vector(loopOp.getOutputs());
inits.append(newInitOperands.begin(), newInitOperands.end());
- auto newLoop = rewriter.create<scf::ForallOp>(
- loc, loopOp.getMixedLowerBound(), loopOp.getMixedUpperBound(),
+ auto newLoop = scf::ForallOp::create(
+ rewriter, loc, loopOp.getMixedLowerBound(), loopOp.getMixedUpperBound(),
loopOp.getMixedStep(), inits, loopOp.getMapping(),
[](OpBuilder &, Location, ValueRange) {});
@@ -881,9 +881,9 @@ FailureOr<LoopLikeOpInterface> yieldTiledValuesAndReplaceLoop<scf::ForallOp>(
tiledValues, regionIterArgs, resultOffsets, resultSizes)) {
SmallVector<OpFoldResult> resultStride(resultOffset.size(),
rewriter.getIndexAttr(1));
- rewriter.create<tensor::ParallelInsertSliceOp>(
- terminator.getLoc(), tiledValue, iterArg, resultOffset, resultSize,
- resultStride);
+ tensor::ParallelInsertSliceOp::create(rewriter, terminator.getLoc(),
+ tiledValue, iterArg, resultOffset,
+ resultSize, resultStride);
}
rewriter.replaceOp(loopOp,
@@ -932,9 +932,9 @@ static LogicalResult addInitOperandsToLoopNest(
// Create a new loop with the new init values for this loop.
SmallVector<Value> newInits = llvm::to_vector(forLoop.getInitArgs());
newInits.append(newInitValues.begin(), newInitValues.end());
- auto newLoop = rewriter.create<scf::ForOp>(
- forLoop.getLoc(), forLoop.getLowerBound(), forLoop.getUpperBound(),
- forLoop.getStep(), newInits,
+ auto newLoop = scf::ForOp::create(
+ rewriter, forLoop.getLoc(), forLoop.getLowerBound(),
+ forLoop.getUpperBound(), forLoop.getStep(), newInits,
[&](OpBuilder &b, Location loc, Value iv, ValueRange iterArgs) {});
// Merge the body of the new loop with the body of the old loops.
@@ -1416,8 +1416,8 @@ FailureOr<SmallVector<Operation *>> mlir::scf::yieldReplacementForFusedProducer(
rewriter.setInsertionPoint(tiledDestStyleOp);
for (const auto &&[index, newRegionArg] :
llvm::enumerate(newRegionIterArgs)) {
- auto destSlice = rewriter.create<tensor::ExtractSliceOp>(
- loc, newRegionArg, offsetList[index], sizesList[index],
+ auto destSlice = tensor::ExtractSliceOp::create(
+ rewriter, loc, newRegionArg, offsetList[index], sizesList[index],
SmallVector<OpFoldResult>(offsetList[index].size(),
rewriter.getIndexAttr(1)));
generatedSlices.push_back(destSlice);
@@ -2089,8 +2089,8 @@ cloneAsInsertSlice<tensor::InsertSliceOp>(RewriterBase &rewriter,
template <>
tensor::InsertSliceOp cloneAsInsertSlice<tensor::ParallelInsertSliceOp>(
RewriterBase &rewriter, tensor::ParallelInsertSliceOp insertSliceOp) {
- return rewriter.create<tensor::InsertSliceOp>(
- insertSliceOp->getLoc(), insertSliceOp.getSource(),
+ return tensor::InsertSliceOp::create(
+ rewriter, insertSliceOp->getLoc(), insertSliceOp.getSource(),
insertSliceOp.getDest(), insertSliceOp.getMixedOffsets(),
insertSliceOp.getMixedSizes(), insertSliceOp.getMixedStrides());
}
@@ -2311,8 +2311,9 @@ mlir::scf::tileAndFuseConsumerOfSlices(
rewriter.setInsertionPoint(tiledDestStyleOp);
for (const auto &&[index, newRegionArg] :
llvm::enumerate(newRegionIterArgs)) {
- auto destSlice = rewriter.create<tensor::ExtractSliceOp>(
- loc, newRegionArg, resultOffsets[index], resultSizes[index],
+ auto destSlice = tensor::ExtractSliceOp::create(
+ rewriter, loc, newRegionArg, resultOffsets[index],
+ resultSizes[index],
SmallVector<OpFoldResult>(resultOffsets[index].size(),
rewriter.getIndexAttr(1)));
// Make a copy of index to avoid a capturing structured binding, which
@@ -2388,8 +2389,8 @@ mlir::scf::lowerToLoopsUsingSCFForOp(RewriterBase &rewriter,
getValueOrCreateConstantIndexOp(rewriter, loc, loopRange.size);
Value strideVal =
getValueOrCreateConstantIndexOp(rewriter, loc, loopRange.stride);
- auto loop = rewriter.create<scf::ForOp>(op.getLoc(), offsetVal, sizeVal,
- strideVal, ValueRange{});
+ auto loop = scf::ForOp::create(rewriter, op.getLoc(), offsetVal, sizeVal,
+ strideVal, ValueRange{});
loops.push_back(loop);
ivs.push_back(loop.getInductionVar());
rewriter.setInsertionPoint(loop.getBody()->getTerminator());
diff --git a/mlir/lib/Dialect/SCF/Transforms/UpliftWhileToFor.cpp b/mlir/lib/Dialect/SCF/Transforms/UpliftWhileToFor.cpp
index 7e9a4d71251b1..ec1044aaa42ac 100644
--- a/mlir/lib/Dialect/SCF/Transforms/UpliftWhileToFor.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/UpliftWhileToFor.cpp
@@ -189,7 +189,7 @@ FailureOr<scf::ForOp> mlir::scf::upliftWhileToForLoop(RewriterBase &rewriter,
// dummy builder instead.
auto emptyBuilder = [](OpBuilder &, Location, Value, ValueRange) {};
auto newLoop =
- rewriter.create<scf::ForOp>(loc, lb, ub, step, newArgs, emptyBuilder);
+ scf::ForOp::create(rewriter, loc, lb, ub, step, newArgs, emptyBuilder);
Block *newBody = newLoop.getBody();
@@ -236,18 +236,18 @@ FailureOr<scf::ForOp> mlir::scf::upliftWhileToForLoop(RewriterBase &rewriter,
rewriter.setInsertionPointAfter(newLoop);
Value one;
if (isa<IndexType>(step.getType())) {
- one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+ one = arith::ConstantIndexOp::create(rewriter, loc, 1);
} else {
- one = rewriter.create<arith::ConstantIntOp>(loc, step.getType(), 1);
+ one = arith::ConstantIntOp::create(rewriter, loc, step.getType(), 1);
}
- Value stepDec = rewriter.create<arith::SubIOp>(loc, step, one);
- Value len = rewriter.create<arith::SubIOp>(loc, ub, lb);
- len = rewriter.create<arith::AddIOp>(loc, len, stepDec);
- len = rewriter.create<arith::DivSIOp>(loc, len, step);
- len = rewriter.create<arith::SubIOp>(loc, len, one);
- Value res = rewriter.create<arith::MulIOp>(loc, len, step);
- res = rewriter.create<arith::AddIOp>(loc, lb, res);
+ Value stepDec = arith::SubIOp::create(rewriter, loc, step, one);
+ Value len = arith::SubIOp::create(rewriter, loc, ub, lb);
+ len = arith::AddIOp::create(rewriter, loc, len, stepDec);
+ len = arith::DivSIOp::create(rewriter, loc, len, step);
+ len = arith::SubIOp::create(rewriter, loc, len, one);
+ Value res = arith::MulIOp::create(rewriter, loc, len, step);
+ res = arith::AddIOp::create(rewriter, loc, lb, res);
// Reconstruct `scf.while` results, inserting final induction var value
// into proper place.
diff --git a/mlir/lib/Dialect/SCF/Transforms/WrapInZeroTripCheck.cpp b/mlir/lib/Dialect/SCF/Transforms/WrapInZeroTripCheck.cpp
index f829208ce8798..db504fe157dc9 100644
--- a/mlir/lib/Dialect/SCF/Transforms/WrapInZeroTripCheck.cpp
+++ b/mlir/lib/Dialect/SCF/Transforms/WrapInZeroTripCheck.cpp
@@ -96,8 +96,8 @@ FailureOr<scf::WhileOp> mlir::scf::wrapWhileLoopInZeroTripCheck(
condOp.getArgs(), [&](Value arg) { return mapper.lookupOrDefault(arg); });
// Create rotated while loop.
- auto newLoopOp = rewriter.create<scf::WhileOp>(
- whileOp.getLoc(), whileOp.getResultTypes(), clonedCondArgs,
+ auto newLoopOp = scf::WhileOp::create(
+ rewriter, whileOp.getLoc(), whileOp.getResultTypes(), clonedCondArgs,
[&](OpBuilder &builder, Location loc, ValueRange args) {
// Rotate and move the loop body into before block.
auto newBlock = builder.getBlock();
@@ -109,21 +109,21 @@ FailureOr<scf::WhileOp> mlir::scf::wrapWhileLoopInZeroTripCheck(
},
[&](OpBuilder &builder, Location loc, ValueRange args) {
// Pass through values.
- builder.create<scf::YieldOp>(loc, args);
+ scf::YieldOp::create(builder, loc, args);
});
// Create zero-trip-check and move the while loop in.
- auto ifOp = rewriter.create<scf::IfOp>(
- whileOp.getLoc(), clonedCondition,
+ auto ifOp = scf::IfOp::create(
+ rewriter, whileOp.getLoc(), clonedCondition,
[&](OpBuilder &builder, Location loc) {
// Then runs the while loop.
rewriter.moveOpBefore(newLoopOp, builder.getInsertionBlock(),
builder.getInsertionPoint());
- builder.create<scf::YieldOp>(loc, newLoopOp.getResults());
+ scf::YieldOp::create(builder, loc, newLoopOp.getResults());
},
[&](OpBuilder &builder, Location loc) {
// Else returns the results from precondition.
- builder.create<scf::YieldOp>(loc, clonedCondArgs);
+ scf::YieldOp::create(builder, loc, clonedCondArgs);
});
rewriter.replaceOp(whileOp, ifOp);
diff --git a/mlir/lib/Dialect/SCF/Utils/Utils.cpp b/mlir/lib/Dialect/SCF/Utils/Utils.cpp
index 062268a702b75..4025ec68ed134 100644
--- a/mlir/lib/Dialect/SCF/Utils/Utils.cpp
+++ b/mlir/lib/Dialect/SCF/Utils/Utils.cpp
@@ -149,7 +149,7 @@ FailureOr<func::FuncOp> mlir::outlineSingleBlockRegion(RewriterBase &rewriter,
FunctionType::get(rewriter.getContext(), outlinedFuncArgTypes,
originalTerminator->getOperandTypes());
auto outlinedFunc =
- rewriter.create<func::FuncOp>(loc, funcName, outlinedFuncType);
+ func::FuncOp::create(rewriter, loc, funcName, outlinedFuncType);
Block *outlinedFuncBody = outlinedFunc.addEntryBlock();
// Merge blocks while replacing the original block operands.
@@ -164,8 +164,8 @@ FailureOr<func::FuncOp> mlir::outlineSingleBlockRegion(RewriterBase &rewriter,
outlinedFuncBlockArgs.take_front(numOriginalBlockArguments));
// Explicitly set up a new ReturnOp terminator.
rewriter.setInsertionPointToEnd(outlinedFuncBody);
- rewriter.create<func::ReturnOp>(loc, originalTerminator->getResultTypes(),
- originalTerminator->getOperands());
+ func::ReturnOp::create(rewriter, loc, originalTerminator->getResultTypes(),
+ originalTerminator->getOperands());
}
// Reconstruct the block that was deleted and add a
@@ -181,7 +181,7 @@ FailureOr<func::FuncOp> mlir::outlineSingleBlockRegion(RewriterBase &rewriter,
SmallVector<Value> callValues;
llvm::append_range(callValues, newBlock->getArguments());
llvm::append_range(callValues, outlinedValues);
- auto call = rewriter.create<func::CallOp>(loc, outlinedFunc, callValues);
+ auto call = func::CallOp::create(rewriter, loc, outlinedFunc, callValues);
if (callOp)
*callOp = call;
@@ -270,12 +270,12 @@ static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
assert(dividend.getType().isIntOrIndex() &&
"expected integer or index-typed value");
- Value divisorMinusOneCst = builder.create<arith::ConstantOp>(
- loc, builder.getIntegerAttr(dividend.getType(), divisor - 1));
- Value divisorCst = builder.create<arith::ConstantOp>(
- loc, builder.getIntegerAttr(dividend.getType(), divisor));
- Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOneCst);
- return builder.create<arith::DivUIOp>(loc, sum, divisorCst);
+ Value divisorMinusOneCst = arith::ConstantOp::create(
+ builder, loc, builder.getIntegerAttr(dividend.getType(), divisor - 1));
+ Value divisorCst = arith::ConstantOp::create(
+ builder, loc, builder.getIntegerAttr(dividend.getType(), divisor));
+ Value sum = arith::AddIOp::create(builder, loc, dividend, divisorMinusOneCst);
+ return arith::DivUIOp::create(builder, loc, sum, divisorCst);
}
// Build the IR that performs ceil division of a positive value by another
@@ -286,11 +286,11 @@ static Value ceilDivPositive(OpBuilder &builder, Location loc, Value dividend,
Value divisor) {
assert(dividend.getType().isIntOrIndex() &&
"expected integer or index-typed value");
- Value cstOne = builder.create<arith::ConstantOp>(
- loc, builder.getOneAttr(dividend.getType()));
- Value divisorMinusOne = builder.create<arith::SubIOp>(loc, divisor, cstOne);
- Value sum = builder.create<arith::AddIOp>(loc, dividend, divisorMinusOne);
- return builder.create<arith::DivUIOp>(loc, sum, divisor);
+ Value cstOne = arith::ConstantOp::create(
+ builder, loc, builder.getOneAttr(dividend.getType()));
+ Value divisorMinusOne = arith::SubIOp::create(builder, loc, divisor, cstOne);
+ Value sum = arith::AddIOp::create(builder, loc, dividend, divisorMinusOne);
+ return arith::DivUIOp::create(builder, loc, sum, divisor);
}
/// Returns the trip count of `forOp` if its' low bound, high bound and step are
@@ -400,18 +400,20 @@ FailureOr<UnrolledLoopInfo> mlir::loopUnrollByFactor(
// Create constant for 'upperBoundUnrolled' and set epilogue loop flag.
generateEpilogueLoop = upperBoundUnrolledCst < ubCst;
if (generateEpilogueLoop)
- upperBoundUnrolled = boundsBuilder.create<arith::ConstantOp>(
- loc, boundsBuilder.getIntegerAttr(forOp.getUpperBound().getType(),
- upperBoundUnrolledCst));
+ upperBoundUnrolled = arith::ConstantOp::create(
+ boundsBuilder, loc,
+ boundsBuilder.getIntegerAttr(forOp.getUpperBound().getType(),
+ upperBoundUnrolledCst));
else
upperBoundUnrolled = forOp.getUpperBound();
// Create constant for 'stepUnrolled'.
- stepUnrolled = stepCst == stepUnrolledCst
- ? step
- : boundsBuilder.create<arith::ConstantOp>(
- loc, boundsBuilder.getIntegerAttr(
- step.getType(), stepUnrolledCst));
+ stepUnrolled =
+ stepCst == stepUnrolledCst
+ ? step
+ : arith::ConstantOp::create(boundsBuilder, loc,
+ boundsBuilder.getIntegerAttr(
+ step.getType(), stepUnrolledCst));
} else {
// Dynamic loop bounds computation.
// TODO: Add dynamic asserts for negative lb/ub/step, or
@@ -419,22 +421,23 @@ FailureOr<UnrolledLoopInfo> mlir::loopUnrollByFactor(
auto lowerBound = forOp.getLowerBound();
auto upperBound = forOp.getUpperBound();
Value
diff =
- boundsBuilder.create<arith::SubIOp>(loc, upperBound, lowerBound);
+ arith::SubIOp::create(boundsBuilder, loc, upperBound, lowerBound);
Value tripCount = ceilDivPositive(boundsBuilder, loc,
diff , step);
- Value unrollFactorCst = boundsBuilder.create<arith::ConstantOp>(
- loc, boundsBuilder.getIntegerAttr(tripCount.getType(), unrollFactor));
+ Value unrollFactorCst = arith::ConstantOp::create(
+ boundsBuilder, loc,
+ boundsBuilder.getIntegerAttr(tripCount.getType(), unrollFactor));
Value tripCountRem =
- boundsBuilder.create<arith::RemSIOp>(loc, tripCount, unrollFactorCst);
+ arith::RemSIOp::create(boundsBuilder, loc, tripCount, unrollFactorCst);
// Compute tripCountEvenMultiple = tripCount - (tripCount % unrollFactor)
Value tripCountEvenMultiple =
- boundsBuilder.create<arith::SubIOp>(loc, tripCount, tripCountRem);
+ arith::SubIOp::create(boundsBuilder, loc, tripCount, tripCountRem);
// Compute upperBoundUnrolled = lowerBound + tripCountEvenMultiple * step
- upperBoundUnrolled = boundsBuilder.create<arith::AddIOp>(
- loc, lowerBound,
- boundsBuilder.create<arith::MulIOp>(loc, tripCountEvenMultiple, step));
+ upperBoundUnrolled = arith::AddIOp::create(
+ boundsBuilder, loc, lowerBound,
+ arith::MulIOp::create(boundsBuilder, loc, tripCountEvenMultiple, step));
// Scale 'step' by 'unrollFactor'.
stepUnrolled =
- boundsBuilder.create<arith::MulIOp>(loc, step, unrollFactorCst);
+ arith::MulIOp::create(boundsBuilder, loc, step, unrollFactorCst);
}
UnrolledLoopInfo resultLoops;
@@ -470,11 +473,11 @@ FailureOr<UnrolledLoopInfo> mlir::loopUnrollByFactor(
forOp.getBody(), forOp.getInductionVar(), unrollFactor,
[&](unsigned i, Value iv, OpBuilder b) {
// iv' = iv + step * i;
- auto stride = b.create<arith::MulIOp>(
- loc, step,
- b.create<arith::ConstantOp>(loc,
- b.getIntegerAttr(iv.getType(), i)));
- return b.create<arith::AddIOp>(loc, iv, stride);
+ auto stride = arith::MulIOp::create(
+ b, loc, step,
+ arith::ConstantOp::create(b, loc,
+ b.getIntegerAttr(iv.getType(), i)));
+ return arith::AddIOp::create(b, loc, iv, stride);
},
annotateFn, iterArgs, yieldedValues);
// Promote the loop body up if this has turned into a single iteration loop.
@@ -777,13 +780,13 @@ void mlir::denormalizeInductionVariable(RewriterBase &rewriter, Location loc,
if (!isStepOne) {
Value origStepValue =
getValueOrCreateConstantIntOp(rewriter, loc, origStep);
- scaled = rewriter.create<arith::MulIOp>(loc, normalizedIv, origStepValue);
+ scaled = arith::MulIOp::create(rewriter, loc, normalizedIv, origStepValue);
preserve.insert(scaled.getDefiningOp());
}
denormalizedIv = scaled;
if (!isZeroBased) {
Value origLbValue = getValueOrCreateConstantIntOp(rewriter, loc, origLb);
- denormalizedIv = rewriter.create<arith::AddIOp>(loc, scaled, origLbValue);
+ denormalizedIv = arith::AddIOp::create(rewriter, loc, scaled, origLbValue);
preserve.insert(denormalizedIv.getDefiningOp());
}
@@ -819,8 +822,8 @@ static Value getProductOfIntsOrIndexes(RewriterBase &rewriter, Location loc,
if (vOne && vOne.value() == 1)
continue;
if (productOf)
- productOf =
- rewriter.create<arith::MulIOp>(loc, productOf.value(), v).getResult();
+ productOf = arith::MulIOp::create(rewriter, loc, productOf.value(), v)
+ .getResult();
else
productOf = v;
}
@@ -846,9 +849,8 @@ delinearizeInductionVariable(RewriterBase &rewriter, Location loc,
Value linearizedIv, ArrayRef<Value> ubs) {
if (linearizedIv.getType().isIndex()) {
- Operation *delinearizedOp =
- rewriter.create<affine::AffineDelinearizeIndexOp>(loc, linearizedIv,
- ubs);
+ Operation *delinearizedOp = affine::AffineDelinearizeIndexOp::create(
+ rewriter, loc, linearizedIv, ubs);
auto resultVals = llvm::map_to_vector(
delinearizedOp->getResults(), [](OpResult r) -> Value { return r; });
return {resultVals, SmallPtrSet<Operation *, 2>{delinearizedOp}};
@@ -870,8 +872,8 @@ delinearizeInductionVariable(RewriterBase &rewriter, Location loc,
if (!isUbOne.test(index)) {
break;
}
- delinearizedIvs[index] = rewriter.create<arith::ConstantOp>(
- loc, rewriter.getZeroAttr(ub.getType()));
+ delinearizedIvs[index] = arith::ConstantOp::create(
+ rewriter, loc, rewriter.getZeroAttr(ub.getType()));
numLeadingOneUbs++;
}
@@ -879,17 +881,17 @@ delinearizeInductionVariable(RewriterBase &rewriter, Location loc,
for (unsigned i = numLeadingOneUbs, e = ubs.size(); i < e; ++i) {
unsigned idx = ubs.size() - (i - numLeadingOneUbs) - 1;
if (i != numLeadingOneUbs && !isUbOne.test(idx + 1)) {
- previous = rewriter.create<arith::DivSIOp>(loc, previous, ubs[idx + 1]);
+ previous = arith::DivSIOp::create(rewriter, loc, previous, ubs[idx + 1]);
preservedUsers.insert(previous.getDefiningOp());
}
Value iv = previous;
if (i != e - 1) {
if (!isUbOne.test(idx)) {
- iv = rewriter.create<arith::RemSIOp>(loc, previous, ubs[idx]);
+ iv = arith::RemSIOp::create(rewriter, loc, previous, ubs[idx]);
preservedUsers.insert(iv.getDefiningOp());
} else {
- iv = rewriter.create<arith::ConstantOp>(
- loc, rewriter.getZeroAttr(ubs[idx].getType()));
+ iv = arith::ConstantOp::create(
+ rewriter, loc, rewriter.getZeroAttr(ubs[idx].getType()));
}
}
delinearizedIvs[idx] = iv;
@@ -1089,13 +1091,13 @@ void mlir::collapseParallelLoops(
// Combine iteration spaces.
SmallVector<Value, 3> lowerBounds, upperBounds, steps;
- auto cst0 = rewriter.create<arith::ConstantIndexOp>(loc, 0);
- auto cst1 = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+ auto cst0 = arith::ConstantIndexOp::create(rewriter, loc, 0);
+ auto cst1 = arith::ConstantIndexOp::create(rewriter, loc, 1);
for (auto &sortedDimension : sortedDimensions) {
- Value newUpperBound = rewriter.create<arith::ConstantIndexOp>(loc, 1);
+ Value newUpperBound = arith::ConstantIndexOp::create(rewriter, loc, 1);
for (auto idx : sortedDimension) {
- newUpperBound = rewriter.create<arith::MulIOp>(
- loc, newUpperBound, normalizedUpperBounds[idx]);
+ newUpperBound = arith::MulIOp::create(rewriter, loc, newUpperBound,
+ normalizedUpperBounds[idx]);
}
lowerBounds.push_back(cst0);
steps.push_back(cst1);
@@ -1108,8 +1110,8 @@ void mlir::collapseParallelLoops(
// value. The remainders then determine based on that range, which iteration
// of the original induction value this represents. This is a normalized value
// that is un-normalized already by the previous logic.
- auto newPloop = rewriter.create<scf::ParallelOp>(
- loc, lowerBounds, upperBounds, steps,
+ auto newPloop = scf::ParallelOp::create(
+ rewriter, loc, lowerBounds, upperBounds, steps,
[&](OpBuilder &insideBuilder, Location, ValueRange ploopIVs) {
for (unsigned i = 0, e = combinedDimensions.size(); i < e; ++i) {
Value previous = ploopIVs[i];
@@ -1119,15 +1121,15 @@ void mlir::collapseParallelLoops(
unsigned idx = combinedDimensions[i][j];
// Determine the current induction value's current loop iteration
- Value iv = insideBuilder.create<arith::RemSIOp>(
- loc, previous, normalizedUpperBounds[idx]);
+ Value iv = arith::RemSIOp::create(insideBuilder, loc, previous,
+ normalizedUpperBounds[idx]);
replaceAllUsesInRegionWith(loops.getBody()->getArgument(idx), iv,
loops.getRegion());
// Remove the effect of the current induction value to prepare for
// the next value.
- previous = insideBuilder.create<arith::DivSIOp>(
- loc, previous, normalizedUpperBounds[idx]);
+ previous = arith::DivSIOp::create(insideBuilder, loc, previous,
+ normalizedUpperBounds[idx]);
}
// The final induction value is just the remaining value.
@@ -1237,7 +1239,7 @@ static Loops stripmineSink(scf::ForOp forOp, Value factor,
auto iv = forOp.getInductionVar();
OpBuilder b(forOp);
- forOp.setStep(b.create<arith::MulIOp>(forOp.getLoc(), originalStep, factor));
+ forOp.setStep(arith::MulIOp::create(b, forOp.getLoc(), originalStep, factor));
Loops innerLoops;
for (auto t : targets) {
@@ -1247,12 +1249,12 @@ static Loops stripmineSink(scf::ForOp forOp, Value factor,
// Insert newForOp before the terminator of `t`.
auto b = OpBuilder::atBlockTerminator((t.getBody()));
- Value stepped = b.create<arith::AddIOp>(t.getLoc(), iv, forOp.getStep());
+ Value stepped = arith::AddIOp::create(b, t.getLoc(), iv, forOp.getStep());
Value ub =
- b.create<arith::MinSIOp>(t.getLoc(), forOp.getUpperBound(), stepped);
+ arith::MinSIOp::create(b, t.getLoc(), forOp.getUpperBound(), stepped);
// Splice [begin, begin + nOps - 1) into `newForOp` and replace uses.
- auto newForOp = b.create<scf::ForOp>(t.getLoc(), iv, ub, originalStep);
+ auto newForOp = scf::ForOp::create(b, t.getLoc(), iv, ub, originalStep);
newForOp.getBody()->getOperations().splice(
newForOp.getBody()->getOperations().begin(),
t.getBody()->getOperations(), begin, std::next(begin, nOps - 1));
@@ -1339,8 +1341,8 @@ TileLoops mlir::extractFixedOuterLoops(scf::ForOp rootForOp,
auto forOp = forOps[i];
OpBuilder builder(forOp);
auto loc = forOp.getLoc();
- Value
diff = builder.create<arith::SubIOp>(loc, forOp.getUpperBound(),
- forOp.getLowerBound());
+ Value
diff = arith::SubIOp::create(builder, loc, forOp.getUpperBound(),
+ forOp.getLowerBound());
Value numIterations = ceilDivPositive(builder, loc,
diff , forOp.getStep());
Value iterationsPerBlock =
ceilDivPositive(builder, loc, numIterations, sizes[i]);
@@ -1372,9 +1374,10 @@ scf::ForallOp mlir::fuseIndependentSiblingForallLoops(scf::ForallOp target,
// Create a new scf.forall op after the source loop.
rewriter.setInsertionPointAfter(source);
- scf::ForallOp fusedLoop = rewriter.create<scf::ForallOp>(
- source.getLoc(), source.getMixedLowerBound(), source.getMixedUpperBound(),
- source.getMixedStep(), fusedOuts, source.getMapping());
+ scf::ForallOp fusedLoop = scf::ForallOp::create(
+ rewriter, source.getLoc(), source.getMixedLowerBound(),
+ source.getMixedUpperBound(), source.getMixedStep(), fusedOuts,
+ source.getMapping());
// Map control operands.
IRMapping mapping;
@@ -1425,8 +1428,8 @@ scf::ForOp mlir::fuseIndependentSiblingForLoops(scf::ForOp target,
// Create a new scf.for op after the source loop (with scf.yield terminator
// (without arguments) only in case its init_args is empty).
rewriter.setInsertionPointAfter(source);
- scf::ForOp fusedLoop = rewriter.create<scf::ForOp>(
- source.getLoc(), source.getLowerBound(), source.getUpperBound(),
+ scf::ForOp fusedLoop = scf::ForOp::create(
+ rewriter, source.getLoc(), source.getLowerBound(), source.getUpperBound(),
source.getStep(), fusedInitArgs);
// Map original induction variables and operands to those of the fused loop.
@@ -1452,7 +1455,7 @@ scf::ForOp mlir::fuseIndependentSiblingForLoops(scf::ForOp target,
for (Value operand : source.getBody()->getTerminator()->getOperands())
yieldResults.push_back(mapping.lookupOrDefault(operand));
if (!yieldResults.empty())
- rewriter.create<scf::YieldOp>(source.getLoc(), yieldResults);
+ scf::YieldOp::create(rewriter, source.getLoc(), yieldResults);
// Replace old loops by substituting their uses by results of the fused loop.
rewriter.replaceOp(target, fusedLoop.getResults().take_front(numTargetOuts));
@@ -1483,8 +1486,8 @@ FailureOr<scf::ForallOp> mlir::normalizeForallOp(RewriterBase &rewriter,
// Use the normalized builder since the lower bounds are always 0 and the
// steps are always 1.
- auto normalizedForallOp = rewriter.create<scf::ForallOp>(
- loc, newUbs, forallOp.getOutputs(), forallOp.getMapping(),
+ auto normalizedForallOp = scf::ForallOp::create(
+ rewriter, loc, newUbs, forallOp.getOutputs(), forallOp.getMapping(),
[](OpBuilder &, Location, ValueRange) {});
rewriter.inlineRegionBefore(forallOp.getBodyRegion(),
diff --git a/mlir/lib/Dialect/SMT/IR/SMTDialect.cpp b/mlir/lib/Dialect/SMT/IR/SMTDialect.cpp
index 66eed861b2bb7..48c0b1ed8e14f 100644
--- a/mlir/lib/Dialect/SMT/IR/SMTDialect.cpp
+++ b/mlir/lib/Dialect/SMT/IR/SMTDialect.cpp
@@ -30,14 +30,14 @@ Operation *SMTDialect::materializeConstant(OpBuilder &builder, Attribute value,
if (auto attrValue = dyn_cast<BitVectorAttr>(value)) {
assert(bvType == attrValue.getType() &&
"attribute and desired result types have to match");
- return builder.create<BVConstantOp>(loc, attrValue);
+ return BVConstantOp::create(builder, loc, attrValue);
}
}
// BoolType constants can materialize into smt.constant
if (auto boolType = dyn_cast<BoolType>(type)) {
if (auto attrValue = dyn_cast<BoolAttr>(value))
- return builder.create<BoolConstantOp>(loc, attrValue);
+ return BoolConstantOp::create(builder, loc, attrValue);
}
return nullptr;
diff --git a/mlir/lib/Dialect/SMT/IR/SMTOps.cpp b/mlir/lib/Dialect/SMT/IR/SMTOps.cpp
index 8977a3abc125d..c517ef2b18f6f 100644
--- a/mlir/lib/Dialect/SMT/IR/SMTOps.cpp
+++ b/mlir/lib/Dialect/SMT/IR/SMTOps.cpp
@@ -405,7 +405,7 @@ static void buildQuantifier(
SmallVector<Location>(boundVarTypes.size(), odsState.location));
Value returnVal =
bodyBuilder(odsBuilder, odsState.location, block->getArguments());
- odsBuilder.create<smt::YieldOp>(odsState.location, returnVal);
+ smt::YieldOp::create(odsBuilder, odsState.location, returnVal);
}
if (patternBuilder) {
Region *region = odsState.addRegion();
@@ -416,7 +416,7 @@ static void buildQuantifier(
SmallVector<Location>(boundVarTypes.size(), odsState.location));
ValueRange returnVals =
patternBuilder(odsBuilder, odsState.location, block->getArguments());
- odsBuilder.create<smt::YieldOp>(odsState.location, returnVals);
+ smt::YieldOp::create(odsBuilder, odsState.location, returnVals);
}
}
diff --git a/mlir/lib/Dialect/Shape/IR/Shape.cpp b/mlir/lib/Dialect/Shape/IR/Shape.cpp
index 7805599738749..e24f0f87e781d 100644
--- a/mlir/lib/Dialect/Shape/IR/Shape.cpp
+++ b/mlir/lib/Dialect/Shape/IR/Shape.cpp
@@ -150,17 +150,17 @@ Operation *ShapeDialect::materializeConstant(OpBuilder &builder,
Attribute value, Type type,
Location loc) {
if (auto poison = dyn_cast<ub::PoisonAttr>(value))
- return builder.create<ub::PoisonOp>(loc, type, poison);
+ return ub::PoisonOp::create(builder, loc, type, poison);
if (llvm::isa<ShapeType>(type) || isExtentTensorType(type))
- return builder.create<ConstShapeOp>(
- loc, type, llvm::cast<DenseIntElementsAttr>(value));
+ return ConstShapeOp::create(builder, loc, type,
+ llvm::cast<DenseIntElementsAttr>(value));
if (llvm::isa<SizeType>(type))
- return builder.create<ConstSizeOp>(loc, type,
- llvm::cast<IntegerAttr>(value));
+ return ConstSizeOp::create(builder, loc, type,
+ llvm::cast<IntegerAttr>(value));
if (llvm::isa<WitnessType>(type))
- return builder.create<ConstWitnessOp>(loc, type,
- llvm::cast<BoolAttr>(value));
+ return ConstWitnessOp::create(builder, loc, type,
+ llvm::cast<BoolAttr>(value));
return arith::ConstantOp::materialize(builder, value, type, loc);
}
@@ -315,8 +315,8 @@ struct AssumingOpRemoveUnusedResults : public OpRewritePattern<AssumingOp> {
auto newYieldOp =
rewriter.replaceOpWithNewOp<AssumingYieldOp>(yieldOp, newYieldOperands);
rewriter.setInsertionPoint(op);
- auto newOp = rewriter.create<AssumingOp>(
- op.getLoc(), newYieldOp->getOperandTypes(), op.getWitness());
+ auto newOp = AssumingOp::create(
+ rewriter, op.getLoc(), newYieldOp->getOperandTypes(), op.getWitness());
newOp.getDoRegion().takeBody(op.getDoRegion());
// Use the new results to replace the previously used ones.
@@ -384,7 +384,7 @@ void AssumingOp::build(
// Build body.
SmallVector<Value, 2> yieldValues = bodyBuilder(builder, result.location);
- builder.create<AssumingYieldOp>(result.location, yieldValues);
+ AssumingYieldOp::create(builder, result.location, yieldValues);
SmallVector<Type, 2> assumingTypes;
for (Value v : yieldValues)
@@ -735,13 +735,13 @@ struct BroadcastForwardSingleOperandPattern
if (replacement.getType() != op.getType()) {
auto loc = op.getLoc();
if (llvm::isa<ShapeType>(op.getType())) {
- replacement = rewriter.create<FromExtentTensorOp>(loc, replacement);
+ replacement = FromExtentTensorOp::create(rewriter, loc, replacement);
} else {
assert(!llvm::isa<ShapeType>(op.getType()) &&
!llvm::isa<ShapeType>(replacement.getType()) &&
"expect extent tensor cast");
replacement =
- rewriter.create<tensor::CastOp>(loc, op.getType(), replacement);
+ tensor::CastOp::create(rewriter, loc, op.getType(), replacement);
}
}
@@ -779,9 +779,9 @@ struct BroadcastFoldConstantOperandsPattern
auto foldedConstantOperandsTy = RankedTensorType::get(
{static_cast<int64_t>(foldedConstantShape.size())},
rewriter.getIndexType());
- newShapeOperands.push_back(rewriter.create<ConstShapeOp>(
- op.getLoc(), foldedConstantOperandsTy,
- rewriter.getIndexTensorAttr(foldedConstantShape)));
+ newShapeOperands.push_back(
+ ConstShapeOp::create(rewriter, op.getLoc(), foldedConstantOperandsTy,
+ rewriter.getIndexTensorAttr(foldedConstantShape)));
rewriter.replaceOpWithNewOp<BroadcastOp>(op, op.getType(),
newShapeOperands);
return success();
@@ -844,9 +844,9 @@ struct BroadcastConcretizeResultTypePattern
}
}
- auto newOp = rewriter.create<BroadcastOp>(
- op.getLoc(), getExtentTensorType(getContext(), maxRank),
- op.getShapes());
+ auto newOp = BroadcastOp::create(rewriter, op.getLoc(),
+ getExtentTensorType(getContext(), maxRank),
+ op.getShapes());
rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(), newOp);
return success();
}
@@ -1353,11 +1353,11 @@ void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape,
auto loc = result.location;
auto dimAttr = builder.getIndexAttr(dim);
if (llvm::isa<ShapeType>(shape.getType())) {
- Value dim = builder.create<ConstSizeOp>(loc, dimAttr);
+ Value dim = ConstSizeOp::create(builder, loc, dimAttr);
build(builder, result, builder.getType<SizeType>(), shape, dim);
} else {
- Value dim =
- builder.create<arith::ConstantOp>(loc, builder.getIndexType(), dimAttr);
+ Value dim = arith::ConstantOp::create(builder, loc, builder.getIndexType(),
+ dimAttr);
build(builder, result, builder.getIndexType(), shape, dim);
}
}
@@ -1707,8 +1707,8 @@ struct ShapeOfOpToConstShapeOp : public OpRewritePattern<shape::ShapeOfOp> {
rewriter.getIndexTensorAttr(type.getShape()))
.getResult();
if (constShape.getType() != op.getResult().getType())
- constShape = rewriter.create<tensor::CastOp>(
- loc, op.getResult().getType(), constShape);
+ constShape = tensor::CastOp::create(rewriter, loc,
+ op.getResult().getType(), constShape);
rewriter.replaceOp(op, constShape);
return success();
}
@@ -1750,10 +1750,11 @@ struct ShapeOfFromReshape : public OpRewritePattern<shape::ShapeOfOp> {
if (opTensorTy != shapeTensorTy) {
if (opTensorTy.getElementType() == shapeTensorTy.getElementType())
- shape = rewriter.create<tensor::CastOp>(op.getLoc(), opTensorTy, shape);
- else if (!isExtentTensorType(shapeTensorTy))
shape =
- rewriter.create<arith::IndexCastOp>(op.getLoc(), opTensorTy, shape);
+ tensor::CastOp::create(rewriter, op.getLoc(), opTensorTy, shape);
+ else if (!isExtentTensorType(shapeTensorTy))
+ shape = arith::IndexCastOp::create(rewriter, op.getLoc(), opTensorTy,
+ shape);
}
rewriter.replaceOp(op, shape);
diff --git a/mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp b/mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp
index e4054750b9fe5..f6bc22549f8e5 100644
--- a/mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp
+++ b/mlir/lib/Dialect/Shape/Transforms/BufferizableOpInterfaceImpl.cpp
@@ -55,8 +55,8 @@ struct AssumingOpInterface
// Create new op and move over region.
TypeRange newResultTypes(yieldOp.getOperands());
- auto newOp = rewriter.create<shape::AssumingOp>(
- op->getLoc(), newResultTypes, assumingOp.getWitness());
+ auto newOp = shape::AssumingOp::create(
+ rewriter, op->getLoc(), newResultTypes, assumingOp.getWitness());
newOp.getDoRegion().takeBody(assumingOp.getRegion());
// Update all uses of the old op.
@@ -64,8 +64,9 @@ struct AssumingOpInterface
SmallVector<Value> newResults;
for (const auto &it : llvm::enumerate(assumingOp->getResultTypes())) {
if (isa<TensorType>(it.value())) {
- newResults.push_back(rewriter.create<bufferization::ToTensorOp>(
- assumingOp.getLoc(), it.value(), newOp->getResult(it.index())));
+ newResults.push_back(bufferization::ToTensorOp::create(
+ rewriter, assumingOp.getLoc(), it.value(),
+ newOp->getResult(it.index())));
} else {
newResults.push_back(newOp->getResult(it.index()));
}
diff --git a/mlir/lib/Dialect/Shape/Transforms/OutlineShapeComputation.cpp b/mlir/lib/Dialect/Shape/Transforms/OutlineShapeComputation.cpp
index 0fe10728b3045..b6367977b2b9d 100644
--- a/mlir/lib/Dialect/Shape/Transforms/OutlineShapeComputation.cpp
+++ b/mlir/lib/Dialect/Shape/Transforms/OutlineShapeComputation.cpp
@@ -66,7 +66,7 @@ createFuncFromCluster(OpBuilder &b, const SmallVector<Operation *, 8> &cluster,
cluster.empty()
? b.getFunctionType(shape.getType(), shape.getType())
: b.getFunctionType(ValueRange(inputs).getTypes(), shape.getType());
- shape::FuncOp fnOp = b.create<shape::FuncOp>(loc, fnName, fnType);
+ shape::FuncOp fnOp = shape::FuncOp::create(b, loc, fnName, fnType);
Block *block = fnOp.addEntryBlock();
b.setInsertionPointToEnd(block);
IRMapping bvm;
@@ -82,7 +82,7 @@ createFuncFromCluster(OpBuilder &b, const SmallVector<Operation *, 8> &cluster,
llvm::SmallVector<Value, 4> fnReturns;
fnReturns.push_back(bvm.lookupOrDefault(shape));
- b.create<shape::ReturnOp>(loc, fnReturns);
+ shape::ReturnOp::create(b, loc, fnReturns);
fnOp.setPrivate();
return std::make_pair(fnOp, inputs);
}
@@ -184,7 +184,7 @@ class TensorDimOpRewriter : public OpRewritePattern<tensor::DimOp> {
LogicalResult matchAndRewrite(tensor::DimOp op,
PatternRewriter &rewriter) const override {
auto shapeOf =
- rewriter.create<shape::ShapeOfOp>(op.getLoc(), op.getSource());
+ shape::ShapeOfOp::create(rewriter, op.getLoc(), op.getSource());
rewriter.replaceOpWithNewOp<shape::GetExtentOp>(op, op.getType(), shapeOf,
op.getIndex());
return success();
diff --git a/mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp b/mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp
index d83ceab72bba9..3c363f3b62cba 100644
--- a/mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp
+++ b/mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp
@@ -43,14 +43,14 @@ NumElementsOpConverter::matchAndRewrite(NumElementsOp op,
->materializeConstant(rewriter, rewriter.getIndexAttr(1),
valueType, loc)
->getResult(0);
- ReduceOp reduce = rewriter.create<ReduceOp>(loc, op.getShape(), init);
+ ReduceOp reduce = ReduceOp::create(rewriter, loc, op.getShape(), init);
// Generate reduce operator.
Block *body = reduce.getBody();
OpBuilder b = OpBuilder::atBlockEnd(body);
- Value product = b.create<MulOp>(loc, valueType, body->getArgument(1),
- body->getArgument(2));
- b.create<shape::YieldOp>(loc, product);
+ Value product = MulOp::create(b, loc, valueType, body->getArgument(1),
+ body->getArgument(2));
+ shape::YieldOp::create(b, loc, product);
rewriter.replaceOp(op, reduce.getResult());
return success();
More information about the Mlir-commits
mailing list