Skip to content

Commit 258d04c

Browse files
maksleventalmakslevental
authored
[mlir][NFC] update mlir/Dialect create APIs (28/n) (#150641)
See #147168 for more info.
1 parent a6bf40d commit 258d04c

26 files changed

+178
-174
lines changed

‎mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp

Lines changed: 54 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -69,25 +69,25 @@ struct MathCosToVCIX final : OpRewritePattern<math::CosOp> {
6969
if (legalType.isScalable())
7070
// Use arbitrary runtime vector length when vector type is scalable.
7171
// Proper conversion pass should take it from the IR.
72-
rvl = rewriter.create<arith::ConstantOp>(loc,
73-
rewriter.getI64IntegerAttr(9));
72+
rvl = arith::ConstantOp::create(rewriter, loc,
73+
rewriter.getI64IntegerAttr(9));
7474
Value res;
7575
if (n == 1) {
76-
res = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr, vec,
77-
immAttr, rvl);
76+
res = vcix::BinaryImmOp::create(rewriter, loc, legalType, opcodeAttr, vec,
77+
immAttr, rvl);
7878
} else {
7979
const unsigned eltCount = legalType.getShape()[0];
8080
Type eltTy = legalType.getElementType();
81-
Value zero = rewriter.create<arith::ConstantOp>(
82-
loc, eltTy, rewriter.getZeroAttr(eltTy));
83-
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
81+
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
82+
rewriter.getZeroAttr(eltTy));
83+
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
8484
for (unsigned i = 0; i < n; ++i) {
85-
Value extracted = rewriter.create<vector::ScalableExtractOp>(
86-
loc, legalType, vec, i * eltCount);
87-
Value v = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr,
88-
extracted, immAttr, rvl);
89-
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
90-
i * eltCount);
85+
Value extracted = vector::ScalableExtractOp::create(
86+
rewriter, loc, legalType, vec, i * eltCount);
87+
Value v = vcix::BinaryImmOp::create(
88+
rewriter, loc, legalType, opcodeAttr, extracted, immAttr, rvl);
89+
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
90+
i * eltCount);
9191
}
9292
}
9393
rewriter.replaceOp(op, res);
@@ -112,25 +112,25 @@ struct MathSinToVCIX final : OpRewritePattern<math::SinOp> {
112112
if (legalType.isScalable())
113113
// Use arbitrary runtime vector length when vector type is scalable.
114114
// Proper conversion pass should take it from the IR.
115-
rvl = rewriter.create<arith::ConstantOp>(loc,
116-
rewriter.getI64IntegerAttr(9));
115+
rvl = arith::ConstantOp::create(rewriter, loc,
116+
rewriter.getI64IntegerAttr(9));
117117
Value res;
118118
if (n == 1) {
119-
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
120-
vec, rvl);
119+
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
120+
vec, rvl);
121121
} else {
122122
const unsigned eltCount = legalType.getShape()[0];
123123
Type eltTy = legalType.getElementType();
124-
Value zero = rewriter.create<arith::ConstantOp>(
125-
loc, eltTy, rewriter.getZeroAttr(eltTy));
126-
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
124+
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
125+
rewriter.getZeroAttr(eltTy));
126+
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
127127
for (unsigned i = 0; i < n; ++i) {
128-
Value extracted = rewriter.create<vector::ScalableExtractOp>(
129-
loc, legalType, vec, i * eltCount);
130-
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
131-
extracted, extracted, rvl);
132-
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
133-
i * eltCount);
128+
Value extracted = vector::ScalableExtractOp::create(
129+
rewriter, loc, legalType, vec, i * eltCount);
130+
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
131+
extracted, extracted, rvl);
132+
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
133+
i * eltCount);
134134
}
135135
}
136136
rewriter.replaceOp(op, res);
@@ -152,28 +152,28 @@ struct MathTanToVCIX final : OpRewritePattern<math::TanOp> {
152152
Location loc = op.getLoc();
153153
Value vec = op.getOperand();
154154
Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
155-
Value zero = rewriter.create<arith::ConstantOp>(
156-
loc, eltTy, rewriter.getZeroAttr(eltTy));
155+
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
156+
rewriter.getZeroAttr(eltTy));
157157
Value rvl = nullptr;
158158
if (legalType.isScalable())
159159
// Use arbitrary runtime vector length when vector type is scalable.
160160
// Proper conversion pass should take it from the IR.
161-
rvl = rewriter.create<arith::ConstantOp>(loc,
162-
rewriter.getI64IntegerAttr(9));
161+
rvl = arith::ConstantOp::create(rewriter, loc,
162+
rewriter.getI64IntegerAttr(9));
163163
Value res;
164164
if (n == 1) {
165-
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
166-
zero, rvl);
165+
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
166+
zero, rvl);
167167
} else {
168168
const unsigned eltCount = legalType.getShape()[0];
169-
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
169+
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
170170
for (unsigned i = 0; i < n; ++i) {
171-
Value extracted = rewriter.create<vector::ScalableExtractOp>(
172-
loc, legalType, vec, i * eltCount);
173-
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
174-
extracted, zero, rvl);
175-
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
176-
i * eltCount);
171+
Value extracted = vector::ScalableExtractOp::create(
172+
rewriter, loc, legalType, vec, i * eltCount);
173+
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
174+
extracted, zero, rvl);
175+
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
176+
i * eltCount);
177177
}
178178
}
179179
rewriter.replaceOp(op, res);
@@ -195,30 +195,30 @@ struct MathLogToVCIX final : OpRewritePattern<math::LogOp> {
195195
Value vec = op.getOperand();
196196
Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
197197
Value rvl = nullptr;
198-
Value zeroInt = rewriter.create<arith::ConstantOp>(
199-
loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
198+
Value zeroInt = arith::ConstantOp::create(
199+
rewriter, loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
200200
if (legalType.isScalable())
201201
// Use arbitrary runtime vector length when vector type is scalable.
202202
// Proper conversion pass should take it from the IR.
203-
rvl = rewriter.create<arith::ConstantOp>(loc,
204-
rewriter.getI64IntegerAttr(9));
203+
rvl = arith::ConstantOp::create(rewriter, loc,
204+
rewriter.getI64IntegerAttr(9));
205205
Value res;
206206
if (n == 1) {
207-
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
208-
zeroInt, rvl);
207+
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
208+
zeroInt, rvl);
209209
} else {
210210
const unsigned eltCount = legalType.getShape()[0];
211211
Type eltTy = legalType.getElementType();
212-
Value zero = rewriter.create<arith::ConstantOp>(
213-
loc, eltTy, rewriter.getZeroAttr(eltTy));
214-
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
212+
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
213+
rewriter.getZeroAttr(eltTy));
214+
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
215215
for (unsigned i = 0; i < n; ++i) {
216-
Value extracted = rewriter.create<vector::ScalableExtractOp>(
217-
loc, legalType, vec, i * eltCount);
218-
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
219-
extracted, zeroInt, rvl);
220-
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
221-
i * eltCount);
216+
Value extracted = vector::ScalableExtractOp::create(
217+
rewriter, loc, legalType, vec, i * eltCount);
218+
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
219+
extracted, zeroInt, rvl);
220+
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
221+
i * eltCount);
222222
}
223223
}
224224
rewriter.replaceOp(op, res);

‎mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -145,7 +145,7 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
145145
if (reifiedScalable->map.getNumInputs() == 1) {
146146
// The only possible input to the bound is vscale.
147147
vscaleOperand.push_back(std::make_pair(
148-
rewriter.create<vector::VectorScaleOp>(loc), std::nullopt));
148+
vector::VectorScaleOp::create(rewriter, loc), std::nullopt));
149149
}
150150
reified = affine::materializeComputedBound(
151151
rewriter, loc, reifiedScalable->map, vscaleOperand);
@@ -169,8 +169,9 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
169169
rewriter.replaceOp(op, val);
170170
return WalkResult::skip();
171171
}
172-
Value constOp = rewriter.create<arith::ConstantIndexOp>(
173-
op->getLoc(), cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
172+
Value constOp = arith::ConstantIndexOp::create(
173+
rewriter, op->getLoc(),
174+
cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
174175
rewriter.replaceOp(op, constOp);
175176
return WalkResult::skip();
176177
});

‎mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ struct TestEmulateWideIntPass
6060
// casts (and vice versa) and using it insted of `llvm.bitcast`.
6161
auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
6262
Location loc) -> Value {
63-
auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
63+
auto cast = LLVM::BitcastOp::create(builder, loc, type, inputs);
6464
return cast->getResult(0);
6565
};
6666
typeConverter.addSourceMaterialization(addBitcast);

‎mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -48,8 +48,8 @@ static SmallVector<Value> buildDecomposeTuple(OpBuilder &builder,
4848
}
4949
for (unsigned i = 0, e = tupleType.size(); i < e; ++i) {
5050
Type elementType = tupleType.getType(i);
51-
Value element = builder.create<test::GetTupleElementOp>(
52-
loc, elementType, tuple, builder.getI32IntegerAttr(i));
51+
Value element = test::GetTupleElementOp::create(
52+
builder, loc, elementType, tuple, builder.getI32IntegerAttr(i));
5353
decompose(element);
5454
}
5555
};
@@ -94,7 +94,7 @@ static Value buildMakeTupleOp(OpBuilder &builder, TupleType resultType,
9494
}
9595

9696
// Assemble the tuple from the elements.
97-
return builder.create<test::MakeTupleOp>(loc, resultType, elements);
97+
return test::MakeTupleOp::create(builder, loc, resultType, elements);
9898
}
9999

100100
/// A pass for testing call graph type decomposition.

‎mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ struct TestSCFForUtilsPass
5656
SmallVector<Value> newYieldValues;
5757
for (auto yieldVal : oldYieldValues) {
5858
newYieldValues.push_back(
59-
b.create<arith::AddFOp>(loc, yieldVal, yieldVal));
59+
arith::AddFOp::create(b, loc, yieldVal, yieldVal));
6060
}
6161
return newYieldValues;
6262
};
@@ -160,13 +160,13 @@ struct TestSCFPipeliningPass
160160
Value pred) {
161161
Location loc = op->getLoc();
162162
auto ifOp =
163-
rewriter.create<scf::IfOp>(loc, op->getResultTypes(), pred, true);
163+
scf::IfOp::create(rewriter, loc, op->getResultTypes(), pred, true);
164164
// True branch.
165165
rewriter.moveOpBefore(op, &ifOp.getThenRegion().front(),
166166
ifOp.getThenRegion().front().begin());
167167
rewriter.setInsertionPointAfter(op);
168168
if (op->getNumResults() > 0)
169-
rewriter.create<scf::YieldOp>(loc, op->getResults());
169+
scf::YieldOp::create(rewriter, loc, op->getResults());
170170
// False branch.
171171
rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
172172
SmallVector<Value> elseYieldOperands;
@@ -181,12 +181,12 @@ struct TestSCFPipeliningPass
181181
} else {
182182
// Default to assuming constant numeric values.
183183
for (Type type : op->getResultTypes()) {
184-
elseYieldOperands.push_back(rewriter.create<arith::ConstantOp>(
185-
loc, rewriter.getZeroAttr(type)));
184+
elseYieldOperands.push_back(arith::ConstantOp::create(
185+
rewriter, loc, rewriter.getZeroAttr(type)));
186186
}
187187
}
188188
if (op->getNumResults() > 0)
189-
rewriter.create<scf::YieldOp>(loc, elseYieldOperands);
189+
scf::YieldOp::create(rewriter, loc, elseYieldOperands);
190190
return ifOp.getOperation();
191191
}
192192

‎mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -50,23 +50,23 @@ struct TestSCFWhileOpBuilderPass
5050
// Create a WhileOp with the same operands and result types.
5151
TypeRange resultTypes = whileOp->getResultTypes();
5252
ValueRange operands = whileOp->getOperands();
53-
builder.create<WhileOp>(
54-
loc, resultTypes, operands, /*beforeBuilder=*/
53+
WhileOp::create(
54+
builder, loc, resultTypes, operands, /*beforeBuilder=*/
5555
[&](OpBuilder &b, Location loc, ValueRange args) {
5656
// Just cast the before args into the right types for condition.
5757
ImplicitLocOpBuilder builder(loc, b);
5858
auto castOp =
59-
builder.create<UnrealizedConversionCastOp>(resultTypes, args);
60-
auto cmp = builder.create<ConstantIntOp>(/*value=*/1, /*width=*/1);
61-
builder.create<ConditionOp>(cmp, castOp->getResults());
59+
UnrealizedConversionCastOp::create(builder, resultTypes, args);
60+
auto cmp = ConstantIntOp::create(builder, /*value=*/1, /*width=*/1);
61+
ConditionOp::create(builder, cmp, castOp->getResults());
6262
},
6363
/*afterBuilder=*/
6464
[&](OpBuilder &b, Location loc, ValueRange args) {
6565
// Just cast the after args into the right types for yield.
6666
ImplicitLocOpBuilder builder(loc, b);
67-
auto castOp = builder.create<UnrealizedConversionCastOp>(
68-
operands.getTypes(), args);
69-
builder.create<YieldOp>(castOp->getResults());
67+
auto castOp = UnrealizedConversionCastOp::create(
68+
builder, operands.getTypes(), args);
69+
YieldOp::create(builder, castOp->getResults());
7070
});
7171
});
7272
}

‎mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp

Lines changed: 14 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -192,8 +192,8 @@ struct RewriteExtractSliceFromCollapseShapeBase
192192
// Create the destination tensor using the above values.
193193
Type elementType = op.getSourceType().getElementType();
194194
SmallVector<OpFoldResult> outputShape = reifiedShapes[0];
195-
Value dest = rewriter.create<tensor::EmptyOp>(op->getLoc(), outputShape,
196-
elementType);
195+
Value dest = tensor::EmptyOp::create(rewriter, op->getLoc(), outputShape,
196+
elementType);
197197

198198
// Calculate the parameters for the tile loop nest.
199199
FailureOr<tensor::ExtractSliceFromCollapseHelper> params =
@@ -215,8 +215,8 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
215215
PatternRewriter &rewriter) const override {
216216
Location loc = op.getLoc();
217217
const unsigned numTiledDims = helper.getIterationSpaceSizes().size();
218-
auto zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
219-
auto one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
218+
auto zero = arith::ConstantIndexOp::create(rewriter, loc, 0);
219+
auto one = arith::ConstantIndexOp::create(rewriter, loc, 1);
220220
SmallVector<Value> lbs(numTiledDims, zero);
221221
SmallVector<Value> steps(numTiledDims, one);
222222

@@ -228,8 +228,8 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfFor
228228
helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
229229

230230
// Insert the slice into the destination.
231-
return {nestedBuilder.create<tensor::InsertSliceOp>(
232-
loc, tile, iterArgs[0], insertParams)};
231+
return {tensor::InsertSliceOp::create(nestedBuilder, loc, tile,
232+
iterArgs[0], insertParams)};
233233
});
234234
rewriter.replaceOp(op, nest.results);
235235

@@ -245,8 +245,9 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
245245
tensor::ExtractSliceFromCollapseHelper &helper,
246246
PatternRewriter &rewriter) const override {
247247
Location loc = op.getLoc();
248-
auto forallOp = rewriter.create<scf::ForallOp>(
249-
loc, /*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
248+
auto forallOp = scf::ForallOp::create(
249+
rewriter, loc,
250+
/*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
250251
/*outputs=*/dest,
251252
/*mapping=*/std::nullopt,
252253
[&](OpBuilder &nestedBuilder, Location loc, ValueRange regionArgs) {
@@ -261,10 +262,10 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
261262
auto [tile, insertParams] =
262263
helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
263264
// Insert the slice into the destination.
264-
auto term = nestedBuilder.create<scf::InParallelOp>(loc);
265+
auto term = scf::InParallelOp::create(nestedBuilder, loc);
265266
nestedBuilder.setInsertionPointToStart(term.getBody());
266-
nestedBuilder.create<tensor::ParallelInsertSliceOp>(
267-
loc, tile, outputArgs[0], insertParams);
267+
tensor::ParallelInsertSliceOp::create(nestedBuilder, loc, tile,
268+
outputArgs[0], insertParams);
268269
});
269270
rewriter.replaceOp(op, forallOp->getResult(0));
270271
return success();
@@ -355,8 +356,8 @@ static LogicalResult testTrackingListenerReplacements(Operation *rootOp) {
355356
MLIRContext *context = rootOp->getContext();
356357
OpBuilder builder(context);
357358
OwningOpRef<transform::NamedSequenceOp> transformOp =
358-
builder.create<transform::NamedSequenceOp>(
359-
rootOp->getLoc(),
359+
transform::NamedSequenceOp::create(
360+
builder, rootOp->getLoc(),
360361
/*sym_name=*/"test_sequence",
361362
/*function_type=*/
362363
TypeAttr::get(FunctionType::get(context, TypeRange{}, TypeRange{})),

‎mlir/test/lib/Dialect/Test/TestDialect.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -346,7 +346,7 @@ TestDialect::~TestDialect() {
346346

347347
Operation *TestDialect::materializeConstant(OpBuilder &builder, Attribute value,
348348
Type type, Location loc) {
349-
return builder.create<TestOpConstant>(loc, type, value);
349+
return TestOpConstant::create(builder, loc, type, value);
350350
}
351351

352352
void *TestDialect::getRegisteredInterfaceForOp(TypeID typeID,

0 commit comments

Comments
 (0)