Skip to content

[mlir][NFC] update mlir/Dialect create APIs (28/n) #150641

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
makslevental merged 1 commit into from
Jul 25, 2025
Merged

[mlir][NFC] update mlir/Dialect create APIs (28/n) #150641

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
108 changes: 54 additions & 54 deletions mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,25 +69,25 @@ struct MathCosToVCIX final : OpRewritePattern<math::CosOp> {
if (legalType.isScalable())
// Use arbitrary runtime vector length when vector type is scalable.
// Proper conversion pass should take it from the IR.
rvl = rewriter.create<arith::ConstantOp>(loc,
rewriter.getI64IntegerAttr(9));
rvl = arith::ConstantOp::create(rewriter, loc,
rewriter.getI64IntegerAttr(9));
Value res;
if (n == 1) {
res = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr, vec,
immAttr, rvl);
res = vcix::BinaryImmOp::create(rewriter, loc, legalType, opcodeAttr, vec,
immAttr, rvl);
} else {
const unsigned eltCount = legalType.getShape()[0];
Type eltTy = legalType.getElementType();
Value zero = rewriter.create<arith::ConstantOp>(
loc, eltTy, rewriter.getZeroAttr(eltTy));
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
rewriter.getZeroAttr(eltTy));
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
for (unsigned i = 0; i < n; ++i) {
Value extracted = rewriter.create<vector::ScalableExtractOp>(
loc, legalType, vec, i * eltCount);
Value v = rewriter.create<vcix::BinaryImmOp>(loc, legalType, opcodeAttr,
extracted, immAttr, rvl);
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
i * eltCount);
Value extracted = vector::ScalableExtractOp::create(
rewriter, loc, legalType, vec, i * eltCount);
Value v = vcix::BinaryImmOp::create(
rewriter, loc, legalType, opcodeAttr, extracted, immAttr, rvl);
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
i * eltCount);
}
}
rewriter.replaceOp(op, res);
Expand All @@ -112,25 +112,25 @@ struct MathSinToVCIX final : OpRewritePattern<math::SinOp> {
if (legalType.isScalable())
// Use arbitrary runtime vector length when vector type is scalable.
// Proper conversion pass should take it from the IR.
rvl = rewriter.create<arith::ConstantOp>(loc,
rewriter.getI64IntegerAttr(9));
rvl = arith::ConstantOp::create(rewriter, loc,
rewriter.getI64IntegerAttr(9));
Value res;
if (n == 1) {
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
vec, rvl);
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
vec, rvl);
} else {
const unsigned eltCount = legalType.getShape()[0];
Type eltTy = legalType.getElementType();
Value zero = rewriter.create<arith::ConstantOp>(
loc, eltTy, rewriter.getZeroAttr(eltTy));
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
rewriter.getZeroAttr(eltTy));
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
for (unsigned i = 0; i < n; ++i) {
Value extracted = rewriter.create<vector::ScalableExtractOp>(
loc, legalType, vec, i * eltCount);
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
extracted, extracted, rvl);
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
i * eltCount);
Value extracted = vector::ScalableExtractOp::create(
rewriter, loc, legalType, vec, i * eltCount);
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
extracted, extracted, rvl);
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
i * eltCount);
}
}
rewriter.replaceOp(op, res);
Expand All @@ -152,28 +152,28 @@ struct MathTanToVCIX final : OpRewritePattern<math::TanOp> {
Location loc = op.getLoc();
Value vec = op.getOperand();
Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
Value zero = rewriter.create<arith::ConstantOp>(
loc, eltTy, rewriter.getZeroAttr(eltTy));
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
rewriter.getZeroAttr(eltTy));
Value rvl = nullptr;
if (legalType.isScalable())
// Use arbitrary runtime vector length when vector type is scalable.
// Proper conversion pass should take it from the IR.
rvl = rewriter.create<arith::ConstantOp>(loc,
rewriter.getI64IntegerAttr(9));
rvl = arith::ConstantOp::create(rewriter, loc,
rewriter.getI64IntegerAttr(9));
Value res;
if (n == 1) {
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
zero, rvl);
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
zero, rvl);
} else {
const unsigned eltCount = legalType.getShape()[0];
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
for (unsigned i = 0; i < n; ++i) {
Value extracted = rewriter.create<vector::ScalableExtractOp>(
loc, legalType, vec, i * eltCount);
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
extracted, zero, rvl);
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
i * eltCount);
Value extracted = vector::ScalableExtractOp::create(
rewriter, loc, legalType, vec, i * eltCount);
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
extracted, zero, rvl);
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
i * eltCount);
}
}
rewriter.replaceOp(op, res);
Expand All @@ -195,30 +195,30 @@ struct MathLogToVCIX final : OpRewritePattern<math::LogOp> {
Value vec = op.getOperand();
Attribute opcodeAttr = rewriter.getI64IntegerAttr(0);
Value rvl = nullptr;
Value zeroInt = rewriter.create<arith::ConstantOp>(
loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
Value zeroInt = arith::ConstantOp::create(
rewriter, loc, rewriter.getI32Type(), rewriter.getI32IntegerAttr(0));
if (legalType.isScalable())
// Use arbitrary runtime vector length when vector type is scalable.
// Proper conversion pass should take it from the IR.
rvl = rewriter.create<arith::ConstantOp>(loc,
rewriter.getI64IntegerAttr(9));
rvl = arith::ConstantOp::create(rewriter, loc,
rewriter.getI64IntegerAttr(9));
Value res;
if (n == 1) {
res = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr, vec,
zeroInt, rvl);
res = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr, vec,
zeroInt, rvl);
} else {
const unsigned eltCount = legalType.getShape()[0];
Type eltTy = legalType.getElementType();
Value zero = rewriter.create<arith::ConstantOp>(
loc, eltTy, rewriter.getZeroAttr(eltTy));
res = rewriter.create<vector::BroadcastOp>(loc, opType, zero /*dummy*/);
Value zero = arith::ConstantOp::create(rewriter, loc, eltTy,
rewriter.getZeroAttr(eltTy));
res = vector::BroadcastOp::create(rewriter, loc, opType, zero /*dummy*/);
for (unsigned i = 0; i < n; ++i) {
Value extracted = rewriter.create<vector::ScalableExtractOp>(
loc, legalType, vec, i * eltCount);
Value v = rewriter.create<vcix::BinaryOp>(loc, legalType, opcodeAttr,
extracted, zeroInt, rvl);
res = rewriter.create<vector::ScalableInsertOp>(loc, v, res,
i * eltCount);
Value extracted = vector::ScalableExtractOp::create(
rewriter, loc, legalType, vec, i * eltCount);
Value v = vcix::BinaryOp::create(rewriter, loc, legalType, opcodeAttr,
extracted, zeroInt, rvl);
res = vector::ScalableInsertOp::create(rewriter, loc, v, res,
i * eltCount);
}
}
rewriter.replaceOp(op, res);
Expand Down
7 changes: 4 additions & 3 deletions mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -145,7 +145,7 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
if (reifiedScalable->map.getNumInputs() == 1) {
// The only possible input to the bound is vscale.
vscaleOperand.push_back(std::make_pair(
rewriter.create<vector::VectorScaleOp>(loc), std::nullopt));
vector::VectorScaleOp::create(rewriter, loc), std::nullopt));
}
reified = affine::materializeComputedBound(
rewriter, loc, reifiedScalable->map, vscaleOperand);
Expand All @@ -169,8 +169,9 @@ static LogicalResult testReifyValueBounds(FunctionOpInterface funcOp,
rewriter.replaceOp(op, val);
return WalkResult::skip();
}
Value constOp = rewriter.create<arith::ConstantIndexOp>(
op->getLoc(), cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
Value constOp = arith::ConstantIndexOp::create(
rewriter, op->getLoc(),
cast<IntegerAttr>(cast<Attribute>(*reified)).getInt());
rewriter.replaceOp(op, constOp);
return WalkResult::skip();
});
Expand Down
2 changes: 1 addition & 1 deletion mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,7 @@ struct TestEmulateWideIntPass
// casts (and vice versa) and using it insted of `llvm.bitcast`.
auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
Location loc) -> Value {
auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
auto cast = LLVM::BitcastOp::create(builder, loc, type, inputs);
return cast->getResult(0);
};
typeConverter.addSourceMaterialization(addBitcast);
Expand Down
6 changes: 3 additions & 3 deletions mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,8 +48,8 @@ static SmallVector<Value> buildDecomposeTuple(OpBuilder &builder,
}
for (unsigned i = 0, e = tupleType.size(); i < e; ++i) {
Type elementType = tupleType.getType(i);
Value element = builder.create<test::GetTupleElementOp>(
loc, elementType, tuple, builder.getI32IntegerAttr(i));
Value element = test::GetTupleElementOp::create(
builder, loc, elementType, tuple, builder.getI32IntegerAttr(i));
decompose(element);
}
};
Expand Down Expand Up @@ -94,7 +94,7 @@ static Value buildMakeTupleOp(OpBuilder &builder, TupleType resultType,
}

// Assemble the tuple from the elements.
return builder.create<test::MakeTupleOp>(loc, resultType, elements);
return test::MakeTupleOp::create(builder, loc, resultType, elements);
}

/// A pass for testing call graph type decomposition.
Expand Down
12 changes: 6 additions & 6 deletions mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,7 +56,7 @@ struct TestSCFForUtilsPass
SmallVector<Value> newYieldValues;
for (auto yieldVal : oldYieldValues) {
newYieldValues.push_back(
b.create<arith::AddFOp>(loc, yieldVal, yieldVal));
arith::AddFOp::create(b, loc, yieldVal, yieldVal));
}
return newYieldValues;
};
Expand Down Expand Up @@ -160,13 +160,13 @@ struct TestSCFPipeliningPass
Value pred) {
Location loc = op->getLoc();
auto ifOp =
rewriter.create<scf::IfOp>(loc, op->getResultTypes(), pred, true);
scf::IfOp::create(rewriter, loc, op->getResultTypes(), pred, true);
// True branch.
rewriter.moveOpBefore(op, &ifOp.getThenRegion().front(),
ifOp.getThenRegion().front().begin());
rewriter.setInsertionPointAfter(op);
if (op->getNumResults() > 0)
rewriter.create<scf::YieldOp>(loc, op->getResults());
scf::YieldOp::create(rewriter, loc, op->getResults());
// False branch.
rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
SmallVector<Value> elseYieldOperands;
Expand All @@ -181,12 +181,12 @@ struct TestSCFPipeliningPass
} else {
// Default to assuming constant numeric values.
for (Type type : op->getResultTypes()) {
elseYieldOperands.push_back(rewriter.create<arith::ConstantOp>(
loc, rewriter.getZeroAttr(type)));
elseYieldOperands.push_back(arith::ConstantOp::create(
rewriter, loc, rewriter.getZeroAttr(type)));
}
}
if (op->getNumResults() > 0)
rewriter.create<scf::YieldOp>(loc, elseYieldOperands);
scf::YieldOp::create(rewriter, loc, elseYieldOperands);
return ifOp.getOperation();
}

Expand Down
16 changes: 8 additions & 8 deletions mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,23 +50,23 @@ struct TestSCFWhileOpBuilderPass
// Create a WhileOp with the same operands and result types.
TypeRange resultTypes = whileOp->getResultTypes();
ValueRange operands = whileOp->getOperands();
builder.create<WhileOp>(
loc, resultTypes, operands, /*beforeBuilder=*/
WhileOp::create(
builder, loc, resultTypes, operands, /*beforeBuilder=*/
[&](OpBuilder &b, Location loc, ValueRange args) {
// Just cast the before args into the right types for condition.
ImplicitLocOpBuilder builder(loc, b);
auto castOp =
builder.create<UnrealizedConversionCastOp>(resultTypes, args);
auto cmp = builder.create<ConstantIntOp>(/*value=*/1, /*width=*/1);
builder.create<ConditionOp>(cmp, castOp->getResults());
UnrealizedConversionCastOp::create(builder, resultTypes, args);
auto cmp = ConstantIntOp::create(builder, /*value=*/1, /*width=*/1);
ConditionOp::create(builder, cmp, castOp->getResults());
},
/*afterBuilder=*/
[&](OpBuilder &b, Location loc, ValueRange args) {
// Just cast the after args into the right types for yield.
ImplicitLocOpBuilder builder(loc, b);
auto castOp = builder.create<UnrealizedConversionCastOp>(
operands.getTypes(), args);
builder.create<YieldOp>(castOp->getResults());
auto castOp = UnrealizedConversionCastOp::create(
builder, operands.getTypes(), args);
YieldOp::create(builder, castOp->getResults());
});
});
}
Expand Down
27 changes: 14 additions & 13 deletions mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -192,8 +192,8 @@ struct RewriteExtractSliceFromCollapseShapeBase
// Create the destination tensor using the above values.
Type elementType = op.getSourceType().getElementType();
SmallVector<OpFoldResult> outputShape = reifiedShapes[0];
Value dest = rewriter.create<tensor::EmptyOp>(op->getLoc(), outputShape,
elementType);
Value dest = tensor::EmptyOp::create(rewriter, op->getLoc(), outputShape,
elementType);

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

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

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

Expand All @@ -245,8 +245,9 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
tensor::ExtractSliceFromCollapseHelper &helper,
PatternRewriter &rewriter) const override {
Location loc = op.getLoc();
auto forallOp = rewriter.create<scf::ForallOp>(
loc, /*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
auto forallOp = scf::ForallOp::create(
rewriter, loc,
/*numThreads=*/getAsOpFoldResult(helper.getIterationSpaceSizes()),
/*outputs=*/dest,
/*mapping=*/std::nullopt,
[&](OpBuilder &nestedBuilder, Location loc, ValueRange regionArgs) {
Expand All @@ -261,10 +262,10 @@ struct RewriteExtractSliceFromCollapseShapeUsingScfForeach
auto [tile, insertParams] =
helper.emitLoopNestBody(nestedBuilder, loc, outputIvs);
// Insert the slice into the destination.
auto term = nestedBuilder.create<scf::InParallelOp>(loc);
auto term = scf::InParallelOp::create(nestedBuilder, loc);
nestedBuilder.setInsertionPointToStart(term.getBody());
nestedBuilder.create<tensor::ParallelInsertSliceOp>(
loc, tile, outputArgs[0], insertParams);
tensor::ParallelInsertSliceOp::create(nestedBuilder, loc, tile,
outputArgs[0], insertParams);
});
rewriter.replaceOp(op, forallOp->getResult(0));
return success();
Expand Down Expand Up @@ -355,8 +356,8 @@ static LogicalResult testTrackingListenerReplacements(Operation *rootOp) {
MLIRContext *context = rootOp->getContext();
OpBuilder builder(context);
OwningOpRef<transform::NamedSequenceOp> transformOp =
builder.create<transform::NamedSequenceOp>(
rootOp->getLoc(),
transform::NamedSequenceOp::create(
builder, rootOp->getLoc(),
/*sym_name=*/"test_sequence",
/*function_type=*/
TypeAttr::get(FunctionType::get(context, TypeRange{}, TypeRange{})),
Expand Down
2 changes: 1 addition & 1 deletion mlir/test/lib/Dialect/Test/TestDialect.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -346,7 +346,7 @@ TestDialect::~TestDialect() {

Operation *TestDialect::materializeConstant(OpBuilder &builder, Attribute value,
Type type, Location loc) {
return builder.create<TestOpConstant>(loc, type, value);
return TestOpConstant::create(builder, loc, type, value);
}

void *TestDialect::getRegisteredInterfaceForOp(TypeID typeID,
Expand Down
Loading