[Mlir-commits] [mlir] [mlir][NFC] update `mlir/Dialect` create APIs (24/n) (PR #149931)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Mon Jul 21 15:47:15 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir
Author: Maksim Levental (makslevental)
<details>
<summary>Changes</summary>
See https://github.com/llvm/llvm-project/pull/147168 for more info.
---
Patch is 198.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/149931.diff
26 Files Affected:
- (modified) mlir/lib/Dialect/Vector/IR/VectorOps.cpp (+56-55)
- (modified) mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp (+5-4)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorBitCast.cpp (+4-4)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorBroadcast.cpp (+11-11)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp (+66-64)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorGather.cpp (+25-25)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorInterleave.cpp (+16-14)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorMask.cpp (+19-18)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorMultiReduction.cpp (+36-34)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorScan.cpp (+15-15)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorShapeCast.cpp (+34-30)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorToFromElementsToShuffleTree.cpp (+2-2)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorTransfer.cpp (+26-26)
- (modified) mlir/lib/Dialect/Vector/Transforms/LowerVectorTranspose.cpp (+16-16)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorDistribute.cpp (+71-63)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorDropLeadUnitDim.cpp (+37-34)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorEmulateMaskedLoadStore.cpp (+19-17)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorEmulateNarrowType.cpp (+151-139)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorInsertExtractStridedSliceRewritePatterns.cpp (+24-24)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorLinearize.cpp (+6-5)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorMaskElimination.cpp (+2-2)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp (+24-24)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp (+52-50)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp (+70-66)
- (modified) mlir/lib/Dialect/Vector/Transforms/VectorUnroll.cpp (+34-30)
- (modified) mlir/lib/Dialect/Vector/Utils/VectorUtils.cpp (+4-4)
``````````diff
diff --git a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
index 56f748fbbe1d6..4c00fb58e4d30 100644
--- a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
+++ b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp
@@ -124,7 +124,7 @@ static MaskFormat getMaskFormat(Value mask) {
/// Default callback to build a region with a 'vector.yield' terminator with no
/// arguments.
void mlir::vector::buildTerminatedBody(OpBuilder &builder, Location loc) {
- builder.create<vector::YieldOp>(loc);
+ vector::YieldOp::create(builder, loc);
}
// Helper for verifying combining kinds in contractions and reductions.
@@ -596,16 +596,16 @@ struct ElideUnitDimsInMultiDimReduction
VectorType newMaskType =
VectorType::get(dstVecType.getShape(), rewriter.getI1Type(),
dstVecType.getScalableDims());
- mask = rewriter.create<vector::ShapeCastOp>(loc, newMaskType, mask);
+ mask = vector::ShapeCastOp::create(rewriter, loc, newMaskType, mask);
}
- cast = rewriter.create<vector::ShapeCastOp>(
- loc, reductionOp.getDestType(), reductionOp.getSource());
+ cast = vector::ShapeCastOp::create(
+ rewriter, loc, reductionOp.getDestType(), reductionOp.getSource());
} else {
// This means we are reducing all the dimensions, and all reduction
// dimensions are of size 1. So a simple extraction would do.
if (mask)
- mask = rewriter.create<vector::ExtractOp>(loc, mask);
- cast = rewriter.create<vector::ExtractOp>(loc, reductionOp.getSource());
+ mask = vector::ExtractOp::create(rewriter, loc, mask);
+ cast = vector::ExtractOp::create(rewriter, loc, reductionOp.getSource());
}
Value result =
@@ -672,36 +672,36 @@ Value mlir::vector::getVectorReductionOp(arith::AtomicRMWKind op,
switch (op) {
case arith::AtomicRMWKind::addf:
case arith::AtomicRMWKind::addi:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::ADD, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::ADD, vector);
case arith::AtomicRMWKind::mulf:
case arith::AtomicRMWKind::muli:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MUL, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MUL, vector);
case arith::AtomicRMWKind::minimumf:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MINIMUMF, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MINIMUMF, vector);
case arith::AtomicRMWKind::mins:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MINSI, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MINSI, vector);
case arith::AtomicRMWKind::minu:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MINUI, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MINUI, vector);
case arith::AtomicRMWKind::maximumf:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MAXIMUMF, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MAXIMUMF, vector);
case arith::AtomicRMWKind::maxs:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MAXSI, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MAXSI, vector);
case arith::AtomicRMWKind::maxu:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::MAXUI, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::MAXUI, vector);
case arith::AtomicRMWKind::andi:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::AND, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::AND, vector);
case arith::AtomicRMWKind::ori:
- return builder.create<vector::ReductionOp>(vector.getLoc(),
- CombiningKind::OR, vector);
+ return vector::ReductionOp::create(builder, vector.getLoc(),
+ CombiningKind::OR, vector);
// TODO: Add remaining reduction operations.
default:
(void)emitOptionalError(loc, "Reduction operation type not supported");
@@ -740,8 +740,8 @@ struct ElideSingleElementReduction : public OpRewritePattern<ReductionOp> {
Location loc = reductionOp.getLoc();
if (mask)
- mask = rewriter.create<ExtractOp>(loc, mask);
- Value result = rewriter.create<ExtractOp>(loc, reductionOp.getVector());
+ mask = ExtractOp::create(rewriter, loc, mask);
+ Value result = ExtractOp::create(rewriter, loc, reductionOp.getVector());
if (Value acc = reductionOp.getAcc())
result = vector::makeArithReduction(rewriter, loc, reductionOp.getKind(),
@@ -4172,9 +4172,9 @@ class StridedSliceCreateMaskFolder final
// greater than the vector dim size.
IntegerAttr offsetAttr =
rewriter.getIntegerAttr(maskDimSize.getType(), sliceOffset);
- Value offset = rewriter.create<arith::ConstantOp>(loc, offsetAttr);
+ Value offset = arith::ConstantOp::create(rewriter, loc, offsetAttr);
Value sliceMaskDimSize =
- rewriter.create<arith::SubIOp>(loc, maskDimSize, offset);
+ arith::SubIOp::create(rewriter, loc, maskDimSize, offset);
sliceMaskDimSizes.push_back(sliceMaskDimSize);
}
// Add unchanged dimensions.
@@ -4289,8 +4289,8 @@ class StridedSliceBroadcast final
sizes[i] = 1;
}
}
- source = rewriter.create<ExtractStridedSliceOp>(
- op->getLoc(), source, offsets, sizes,
+ source = ExtractStridedSliceOp::create(
+ rewriter, op->getLoc(), source, offsets, sizes,
getI64SubArray(op.getStrides(), /*dropFront=*/rankDiff));
}
rewriter.replaceOpWithNewOp<BroadcastOp>(op, op.getType(), source);
@@ -4382,8 +4382,8 @@ class ContiguousExtractStridedSliceToExtract final
SmallVector<int64_t> offsets = getI64SubArray(op.getOffsets());
auto extractOffsets = ArrayRef(offsets).take_front(numOffsets);
- Value extract = rewriter.create<vector::ExtractOp>(op->getLoc(), source,
- extractOffsets);
+ Value extract = vector::ExtractOp::create(rewriter, op->getLoc(), source,
+ extractOffsets);
rewriter.replaceOpWithNewOp<vector::ShapeCastOp>(op, op.getType(), extract);
return success();
}
@@ -4413,7 +4413,7 @@ void TransferReadOp::build(OpBuilder &builder, OperationState &result,
Type elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
if (!padding)
- padding = builder.create<ub::PoisonOp>(result.location, elemType);
+ padding = ub::PoisonOp::create(builder, result.location, elemType);
build(builder, result, vectorType, source, indices, permutationMapAttr,
*padding, /*mask=*/Value(), inBoundsAttr);
}
@@ -4431,7 +4431,7 @@ void TransferReadOp::build(OpBuilder &builder, OperationState &result,
SmallVector<bool>(vectorType.getRank(), false));
Type elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
if (!padding)
- padding = builder.create<ub::PoisonOp>(result.location, elemType);
+ padding = ub::PoisonOp::create(builder, result.location, elemType);
build(builder, result, vectorType, source, indices, *padding,
permutationMapAttr, inBoundsAttr);
}
@@ -4450,7 +4450,7 @@ void TransferReadOp::build(OpBuilder &builder, OperationState &result,
SmallVector<bool>(vectorType.getRank(), false));
Type elemType = llvm::cast<ShapedType>(source.getType()).getElementType();
if (!padding)
- padding = builder.create<ub::PoisonOp>(result.location, elemType);
+ padding = ub::PoisonOp::create(builder, result.location, elemType);
build(builder, result, vectorType, source, indices, permutationMapAttr,
*padding,
/*mask=*/Value(), inBoundsAttr);
@@ -4975,7 +4975,7 @@ struct TransferReadAfterWriteToBroadcast
VectorType broadcastedType = VectorType::get(
broadcastShape, defWrite.getVectorType().getElementType(),
broadcastScalableFlags);
- vec = rewriter.create<vector::BroadcastOp>(loc, broadcastedType, vec);
+ vec = vector::BroadcastOp::create(rewriter, loc, broadcastedType, vec);
SmallVector<int64_t> transposePerm(permutation.begin(), permutation.end());
rewriter.replaceOpWithNewOp<vector::TransposeOp>(readOp, vec,
transposePerm);
@@ -5453,13 +5453,14 @@ struct SwapExtractSliceOfTransferWrite
// Swap the tensor::ExtractSliceOp in front of the vector::TransferWriteOp.
// Set all in_bounds to false and let the folder infer them.
SmallVector<bool> newInBounds(vectorShape.size(), false);
- auto newExtractOp = rewriter.create<tensor::ExtractSliceOp>(
- extractOp.getLoc(), insertOp.getSourceType(), insertOp.getDest(),
- insertOp.getMixedOffsets(), insertOp.getMixedSizes(),
- insertOp.getMixedStrides());
- auto newTransferWriteOp = rewriter.create<TransferWriteOp>(
- transferOp.getLoc(), transferOp.getVector(), newExtractOp.getResult(),
- transferOp.getIndices(), transferOp.getPermutationMapAttr(),
+ auto newExtractOp = tensor::ExtractSliceOp::create(
+ rewriter, extractOp.getLoc(), insertOp.getSourceType(),
+ insertOp.getDest(), insertOp.getMixedOffsets(),
+ insertOp.getMixedSizes(), insertOp.getMixedStrides());
+ auto newTransferWriteOp = TransferWriteOp::create(
+ rewriter, transferOp.getLoc(), transferOp.getVector(),
+ newExtractOp.getResult(), transferOp.getIndices(),
+ transferOp.getPermutationMapAttr(),
rewriter.getBoolArrayAttr(newInBounds));
rewriter.modifyOpInPlace(insertOp, [&]() {
insertOp.getSourceMutable().assign(newTransferWriteOp.getResult());
@@ -6983,7 +6984,7 @@ void MaskOp::ensureTerminator(Region ®ion, Builder &builder, Location loc) {
OpBuilder opBuilder(builder.getContext());
Operation *maskedOp = &block.front();
opBuilder.setInsertionPointToEnd(&block);
- opBuilder.create<vector::YieldOp>(loc, maskedOp->getResults());
+ vector::YieldOp::create(opBuilder, loc, maskedOp->getResults());
}
LogicalResult MaskOp::verify() {
@@ -7318,7 +7319,7 @@ void mlir::vector::createMaskOpRegion(OpBuilder &builder,
// Create a block and move the op to that block.
insBlock->getOperations().splice(
insBlock->begin(), maskableOp->getBlock()->getOperations(), maskableOp);
- builder.create<YieldOp>(maskableOp->getLoc(), maskableOp->getResults());
+ YieldOp::create(builder, maskableOp->getLoc(), maskableOp->getResults());
}
/// Creates a vector.mask operation around a maskable operation. Returns the
@@ -7330,12 +7331,12 @@ Operation *mlir::vector::maskOperation(OpBuilder &builder,
if (!mask)
return maskableOp;
if (passthru)
- return builder.create<MaskOp>(maskableOp->getLoc(),
- maskableOp->getResultTypes(), mask, passthru,
- maskableOp, createMaskOpRegion);
- return builder.create<MaskOp>(maskableOp->getLoc(),
- maskableOp->getResultTypes(), mask, maskableOp,
- createMaskOpRegion);
+ return MaskOp::create(builder, maskableOp->getLoc(),
+ maskableOp->getResultTypes(), mask, passthru,
+ maskableOp, createMaskOpRegion);
+ return MaskOp::create(builder, maskableOp->getLoc(),
+ maskableOp->getResultTypes(), mask, maskableOp,
+ createMaskOpRegion);
}
/// Creates a vector select operation that picks values from `newValue` or
@@ -7350,8 +7351,8 @@ Value mlir::vector::selectPassthru(OpBuilder &builder, Value mask,
if (!mask)
return newValue;
- return builder.create<arith::SelectOp>(newValue.getLoc(), newValue.getType(),
- mask, newValue, passthru);
+ return arith::SelectOp::create(builder, newValue.getLoc(), newValue.getType(),
+ mask, newValue, passthru);
}
//===----------------------------------------------------------------------===//
diff --git a/mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp b/mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp
index 9da051150e409..66196194b0585 100644
--- a/mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp
@@ -116,8 +116,8 @@ struct TransferWriteOpInterface
getBuffer(rewriter, writeOp.getBase(), options, state);
if (failed(resultBuffer))
return failure();
- rewriter.create<vector::TransferWriteOp>(
- writeOp.getLoc(), writeOp.getVector(), *resultBuffer,
+ vector::TransferWriteOp::create(
+ rewriter, writeOp.getLoc(), writeOp.getVector(), *resultBuffer,
writeOp.getIndices(), writeOp.getPermutationMapAttr(),
writeOp.getMask(), writeOp.getInBoundsAttr());
replaceOpWithBufferizedValues(rewriter, op, *resultBuffer);
@@ -241,8 +241,9 @@ struct MaskOpInterface
// Create a new vector.mask op.
ValueRange newYieldedValuesRange(newYieldedValues);
TypeRange newResultTypes(newYieldedValuesRange);
- auto newOp = rewriter.create<vector::MaskOp>(
- op->getLoc(), newResultTypes, maskOp.getMask(), maskOp.getPassthru(),
+ auto newOp = vector::MaskOp::create(
+ rewriter, op->getLoc(), newResultTypes, maskOp.getMask(),
+ maskOp.getPassthru(),
/*maskableOp=*/nullptr,
/*maskRegionBuilder=*/[](OpBuilder &b, Operation *) {});
newOp.getRegion().takeBody(maskOp.getMaskRegion());
diff --git a/mlir/lib/Dialect/Vector/Transforms/LowerVectorBitCast.cpp b/mlir/lib/Dialect/Vector/Transforms/LowerVectorBitCast.cpp
index 89930a6bd35fa..4c3a04cfb5bfa 100644
--- a/mlir/lib/Dialect/Vector/Transforms/LowerVectorBitCast.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/LowerVectorBitCast.cpp
@@ -64,14 +64,14 @@ class UnrollBitCastOp final : public OpRewritePattern<vector::BitCastOp> {
VectorType::get(shape, resultType.getElementType(), scalableDims);
Location loc = op.getLoc();
- Value result = rewriter.create<ub::PoisonOp>(loc, resultType);
+ Value result = ub::PoisonOp::create(rewriter, loc, resultType);
for (auto position : *unrollIterator) {
Value extract =
- rewriter.create<vector::ExtractOp>(loc, op.getSource(), position);
+ vector::ExtractOp::create(rewriter, loc, op.getSource(), position);
Value bitcast =
- rewriter.create<vector::BitCastOp>(loc, bitcastResType, extract);
+ vector::BitCastOp::create(rewriter, loc, bitcastResType, extract);
result =
- rewriter.create<vector::InsertOp>(loc, bitcast, result, position);
+ vector::InsertOp::create(rewriter, loc, bitcast, result, position);
}
rewriter.replaceOp(op, result);
diff --git a/mlir/lib/Dialect/Vector/Transforms/LowerVectorBroadcast.cpp b/mlir/lib/Dialect/Vector/Transforms/LowerVectorBroadcast.cpp
index 11dcfe421e0c4..cb8e566869cfd 100644
--- a/mlir/lib/Dialect/Vector/Transforms/LowerVectorBroadcast.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/LowerVectorBroadcast.cpp
@@ -52,7 +52,7 @@ class BroadcastOpLowering : public OpRewritePattern<vector::BroadcastOp> {
// Stretching scalar inside vector (e.g. vector<1xf32>) can use splat.
if (srcRank <= 1 && dstRank == 1) {
- Value ext = rewriter.create<vector::ExtractOp>(loc, op.getSource());
+ Value ext = vector::ExtractOp::create(rewriter, loc, op.getSource());
rewriter.replaceOpWithNewOp<vector::SplatOp>(op, dstType, ext);
return success();
}
@@ -70,10 +70,10 @@ class BroadcastOpLowering : public OpRewritePattern<vector::BroadcastOp> {
// Duplication.
VectorType resType = VectorType::Builder(dstType).dropDim(0);
Value bcst =
- rewriter.create<vector::BroadcastOp>(loc, resType, op.getSource());
- Value result = rewriter.create<ub::PoisonOp>(loc, dstType);
+ vector::BroadcastOp::create(rewriter, loc, resType, op.getSource());
+ Value result = ub::PoisonOp::create(rewriter, loc, dstType);
for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d)
- result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
+ result = vector::InsertOp::create(rewriter, loc, bcst, result, d);
rewriter.replaceOp(op, result);
return success();
}
@@ -111,13 +111,13 @@ class BroadcastOpLowering : public OpRewritePattern<vector::BroadcastOp> {
VectorType resType =
VectorType::get(dstType.getShape().drop_front(), eltType,
dstType.getScalableDims().drop_front());
- Value result = rewriter.create<ub::PoisonOp>(loc, dstType);
+ Value result = ub::PoisonOp::create(rewriter, loc, dstType);
if (m == 0) {
// Stetch at start.
- Value ext = rewriter.create<vector::ExtractOp>(loc, op.getSource(), 0);
- Value bcst = rewriter.create<vector::BroadcastOp>(loc, resType, ext);
+ Value ext = vector::ExtractOp::create(rewriter, loc, op.getSource(), 0);
+ Value bcst = vector::BroadcastOp::create(rewriter, loc, resType, ext);
for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d)
- result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
+ result = vector::InsertOp::create(rewriter, loc, bcst, result, d);
} else {
// Stetch not at start.
if (dstType.getScalableDims()[0]) {
@@ -125,9 +125,9 @@ class BroadcastOpLowering : public OpRewritePattern<vector::BroadcastOp> {
return failure();
}
for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d) {
- Value ext = rewriter.create<vector::ExtractOp>(loc, op.getSource(), d);
- Value bcst = rewriter.create<vector::BroadcastOp>(loc, resType, ext);
- result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
+ Value ext = vector::ExtractOp::create(rewriter, loc, op.getSource(), d);
+ Value bcst = vector::BroadcastOp::create(rewriter, loc, resType, ext);
+ result = vector::InsertOp::create(rewriter, loc, bcst, result, d);
}
}
rewriter.replaceOp(op, result);
diff --git a/mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp b/mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp
index fc6c90f5132c7..65702ffa152d9 100644
--- a/mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp
+++ b/mlir/lib/Dialect/Vector/Transforms/LowerVectorContract.cpp
@@ -81,17 +81,17 @@ static Value reshapeLoad(Location loc, Value val, VectorType type,
// At extraction dimension?
if (index == 0)
- return rewriter.create<vector::ExtractOp>(loc, val, pos);
+ return vector::ExtractOp::create(rewriter, loc, val, pos);
// Unroll leading dimensions.
VectorType vType = VectorType::Builder(type).dropDim(0);
VectorType resType = VectorType::Builder(type).dropDim(index);
- Value result = rewriter.create<arith::ConstantOp>(
- loc, resType, rewriter.getZeroAttr(resType));
+ Value result = arith::ConstantOp::create(rewriter, loc, resType,
+ ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/149931
More information about the Mlir-commits
mailing list