diff options
Diffstat (limited to 'mlir/test/lib')
32 files changed, 315 insertions, 211 deletions
diff --git a/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp b/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp index 8a01a0a..016052c 100644 --- a/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp +++ b/mlir/test/lib/Conversion/MathToVCIX/TestMathToVCIXConversion.cpp @@ -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); @@ -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); @@ -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); @@ -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); diff --git a/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp b/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp index ed5d06d..3569a73 100644 --- a/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp +++ b/mlir/test/lib/Dialect/Affine/TestReifyValueBounds.cpp @@ -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); @@ -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(); }); diff --git a/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp b/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp index 738d4ee59..a792d08 100644 --- a/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp +++ b/mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp @@ -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); diff --git a/mlir/test/lib/Dialect/Bufferization/CMakeLists.txt b/mlir/test/lib/Dialect/Bufferization/CMakeLists.txt index 226e0bb..2ee3222 100644 --- a/mlir/test/lib/Dialect/Bufferization/CMakeLists.txt +++ b/mlir/test/lib/Dialect/Bufferization/CMakeLists.txt @@ -1,5 +1,6 @@ # Exclude tests from libMLIR.so add_mlir_library(MLIRBufferizationTestPasses + TestOneShotModuleBufferize.cpp TestTensorCopyInsertion.cpp TestTensorLikeAndBufferLike.cpp diff --git a/mlir/test/lib/Dialect/Bufferization/TestOneShotModuleBufferize.cpp b/mlir/test/lib/Dialect/Bufferization/TestOneShotModuleBufferize.cpp new file mode 100644 index 0000000..1e2d4a7 --- /dev/null +++ b/mlir/test/lib/Dialect/Bufferization/TestOneShotModuleBufferize.cpp @@ -0,0 +1,57 @@ +//===- TestOneShotModuleBufferzation.cpp - Bufferization Test -----*- c++ +//-*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "mlir/Dialect/Bufferization/IR/Bufferization.h" +#include "mlir/Dialect/Bufferization/Transforms/Bufferize.h" +#include "mlir/Dialect/Bufferization/Transforms/OneShotModuleBufferize.h" +#include "mlir/Dialect/Bufferization/Transforms/Transforms.h" +#include "mlir/Pass/Pass.h" + +using namespace mlir; + +namespace { +struct TestOneShotModuleBufferizePass + : public PassWrapper<TestOneShotModuleBufferizePass, OperationPass<>> { + MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestOneShotModuleBufferizePass) + + TestOneShotModuleBufferizePass() = default; + TestOneShotModuleBufferizePass(const TestOneShotModuleBufferizePass &pass) + : PassWrapper(pass) {} + + void getDependentDialects(DialectRegistry ®istry) const override { + registry.insert<bufferization::BufferizationDialect>(); + } + StringRef getArgument() const final { + return "test-one-shot-module-bufferize"; + } + StringRef getDescription() const final { + return "Pass to test One Shot Module Bufferization"; + } + + void runOnOperation() override { + + llvm::errs() << "Running TestOneShotModuleBufferize on: " + << getOperation()->getName() << "\n"; + bufferization::OneShotBufferizationOptions opt; + + opt.bufferizeFunctionBoundaries = true; + bufferization::BufferizationState bufferizationState; + + if (failed(bufferization::runOneShotModuleBufferize(getOperation(), opt, + bufferizationState))) + signalPassFailure(); + } +}; +} // namespace + +namespace mlir::test { +void registerTestOneShotModuleBufferizePass() { + PassRegistration<TestOneShotModuleBufferizePass>(); +} +} // namespace mlir::test diff --git a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp index d0b62e7..c67bcd9 100644 --- a/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp +++ b/mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp @@ -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); } }; @@ -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. diff --git a/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp b/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp index 9eade75..9a394d2 100644 --- a/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp +++ b/mlir/test/lib/Dialect/SCF/TestSCFUtils.cpp @@ -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; }; @@ -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; @@ -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(); } diff --git a/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp b/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp index d3113c0..d3f7f0e6 100644 --- a/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp +++ b/mlir/test/lib/Dialect/SCF/TestWhileOpBuilder.cpp @@ -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()); }); }); } diff --git a/mlir/test/lib/Dialect/Shard/TestReshardingPartition.cpp b/mlir/test/lib/Dialect/Shard/TestReshardingPartition.cpp index ac71ff6..23fdad1 100644 --- a/mlir/test/lib/Dialect/Shard/TestReshardingPartition.cpp +++ b/mlir/test/lib/Dialect/Shard/TestReshardingPartition.cpp @@ -72,15 +72,14 @@ struct TestReshardingRewritePattern : OpRewritePattern<ShardOp> { ShapedType sourceShardShape = shardShapedType(op.getResult().getType(), grid, op.getSharding()); TypedValue<ShapedType> sourceShard = cast<TypedValue<ShapedType>>( - builder - .create<UnrealizedConversionCastOp>(sourceShardShape, op.getSrc()) + UnrealizedConversionCastOp::create(builder, sourceShardShape, + op.getSrc()) ->getResult(0)); TypedValue<ShapedType> targetShard = reshard(builder, grid, op, targetShardOp, sourceShard); Value newTargetUnsharded = - builder - .create<UnrealizedConversionCastOp>( - targetShardOp.getResult().getType(), targetShard) + UnrealizedConversionCastOp::create( + builder, targetShardOp.getResult().getType(), targetShard) ->getResult(0); rewriter.replaceAllUsesWith(targetShardOp.getResult(), newTargetUnsharded); diff --git a/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp b/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp index 0e191c3..687473e 100644 --- a/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp +++ b/mlir/test/lib/Dialect/Tensor/TestTensorTransforms.cpp @@ -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 = @@ -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); @@ -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); @@ -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) { @@ -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(); @@ -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{})), diff --git a/mlir/test/lib/Dialect/Test/TestAttrDefs.td b/mlir/test/lib/Dialect/Test/TestAttrDefs.td index 382da59..5685004 100644 --- a/mlir/test/lib/Dialect/Test/TestAttrDefs.td +++ b/mlir/test/lib/Dialect/Test/TestAttrDefs.td @@ -347,6 +347,7 @@ def TestCopyCount : Test_Attr<"TestCopyCount"> { let mnemonic = "copy_count"; let parameters = (ins TestParamCopyCount:$copy_count); let assemblyFormat = "`<` $copy_count `>`"; + let genVerifyDecl = 1; } def TestConditionalAliasAttr : Test_Attr<"TestConditionalAlias"> { diff --git a/mlir/test/lib/Dialect/Test/TestAttributes.cpp b/mlir/test/lib/Dialect/Test/TestAttributes.cpp index b31e90f..5890913 100644 --- a/mlir/test/lib/Dialect/Test/TestAttributes.cpp +++ b/mlir/test/lib/Dialect/Test/TestAttributes.cpp @@ -214,6 +214,16 @@ static void printTrueFalse(AsmPrinter &p, std::optional<int> result) { } //===----------------------------------------------------------------------===// +// TestCopyCountAttr Implementation +//===----------------------------------------------------------------------===// + +LogicalResult TestCopyCountAttr::verify( + llvm::function_ref<::mlir::InFlightDiagnostic()> /*emitError*/, + CopyCount /*copy_count*/) { + return success(); +} + +//===----------------------------------------------------------------------===// // CopyCountAttr Implementation //===----------------------------------------------------------------------===// diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp index 1bbf2cc..a4c615b 100644 --- a/mlir/test/lib/Dialect/Test/TestDialect.cpp +++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp @@ -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, diff --git a/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp b/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp index 01ae245..1235a5f 100644 --- a/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp +++ b/mlir/test/lib/Dialect/Test/TestDialectInterfaces.cpp @@ -354,7 +354,7 @@ struct TestInlinerInterface : public DialectInlinerInterface { !(input.getType().isSignlessInteger(16) || input.getType().isSignlessInteger(32))) return nullptr; - return builder.create<TestCastOp>(conversionLoc, resultType, input); + return TestCastOp::create(builder, conversionLoc, resultType, input); } Value handleArgument(OpBuilder &builder, Operation *call, Operation *callable, @@ -362,16 +362,16 @@ struct TestInlinerInterface : public DialectInlinerInterface { DictionaryAttr argumentAttrs) const final { if (!argumentAttrs.contains("test.handle_argument")) return argument; - return builder.create<TestTypeChangerOp>(call->getLoc(), argument.getType(), - argument); + return TestTypeChangerOp::create(builder, call->getLoc(), + argument.getType(), argument); } Value handleResult(OpBuilder &builder, Operation *call, Operation *callable, Value result, DictionaryAttr resultAttrs) const final { if (!resultAttrs.contains("test.handle_result")) return result; - return builder.create<TestTypeChangerOp>(call->getLoc(), result.getType(), - result); + return TestTypeChangerOp::create(builder, call->getLoc(), result.getType(), + result); } void processInlinedCallBlocks( diff --git a/mlir/test/lib/Dialect/Test/TestFromLLVMIRTranslation.cpp b/mlir/test/lib/Dialect/Test/TestFromLLVMIRTranslation.cpp index dc6413b..b98f6ce 100644 --- a/mlir/test/lib/Dialect/Test/TestFromLLVMIRTranslation.cpp +++ b/mlir/test/lib/Dialect/Test/TestFromLLVMIRTranslation.cpp @@ -43,11 +43,11 @@ static LogicalResult convertLoad(OpBuilder &builder, llvm::Instruction *inst, if (failed(addr)) return failure(); // Create the LoadOp - Value loadOp = builder.create<LLVM::LoadOp>( - moduleImport.translateLoc(inst->getDebugLoc()), + Value loadOp = LLVM::LoadOp::create( + builder, moduleImport.translateLoc(inst->getDebugLoc()), moduleImport.convertType(inst->getType()), *addr); - moduleImport.mapValue(inst) = builder.create<SameOperandElementTypeOp>( - loadOp.getLoc(), loadOp.getType(), loadOp, loadOp); + moduleImport.mapValue(inst) = SameOperandElementTypeOp::create( + builder, loadOp.getLoc(), loadOp.getType(), loadOp, loadOp); return success(); } diff --git a/mlir/test/lib/Dialect/Test/TestOpDefs.cpp b/mlir/test/lib/Dialect/Test/TestOpDefs.cpp index 3ab4ef2..53055fe 100644 --- a/mlir/test/lib/Dialect/Test/TestOpDefs.cpp +++ b/mlir/test/lib/Dialect/Test/TestOpDefs.cpp @@ -18,6 +18,32 @@ using namespace mlir; using namespace test; //===----------------------------------------------------------------------===// +// OverridenSymbolVisibilityOp +//===----------------------------------------------------------------------===// + +SymbolTable::Visibility OverriddenSymbolVisibilityOp::getVisibility() { + return SymbolTable::Visibility::Private; +} + +static StringLiteral getVisibilityString(SymbolTable::Visibility visibility) { + switch (visibility) { + case SymbolTable::Visibility::Private: + return "private"; + case SymbolTable::Visibility::Nested: + return "nested"; + case SymbolTable::Visibility::Public: + return "public"; + } +} + +void OverriddenSymbolVisibilityOp::setVisibility( + SymbolTable::Visibility visibility) { + + emitOpError("cannot change visibility of symbol to ") + << getVisibilityString(visibility); +} + +//===----------------------------------------------------------------------===// // TestBranchOp //===----------------------------------------------------------------------===// @@ -286,9 +312,9 @@ LogicalResult OpWithResultShapeInterfaceOp::reifyReturnTypeShapes( llvm::map_range(llvm::seq<int64_t>(0, rank), [&](int64_t dim) -> Value { return builder.createOrFold<tensor::DimOp>(loc, operand, dim); })); - shapes.push_back(builder.create<tensor::FromElementsOp>( - getLoc(), RankedTensorType::get({rank}, builder.getIndexType()), - currShape)); + shapes.push_back(tensor::FromElementsOp::create( + builder, getLoc(), + RankedTensorType::get({rank}, builder.getIndexType()), currShape)); } return success(); } @@ -1302,8 +1328,8 @@ llvm::SmallVector<MemorySlot> TestMultiSlotAlloca::getPromotableSlots() { Value TestMultiSlotAlloca::getDefaultValue(const MemorySlot &slot, OpBuilder &builder) { - return builder.create<TestOpConstant>(getLoc(), slot.elemType, - builder.getI32IntegerAttr(42)); + return TestOpConstant::create(builder, getLoc(), slot.elemType, + builder.getI32IntegerAttr(42)); } void TestMultiSlotAlloca::handleBlockArgument(const MemorySlot &slot, @@ -1335,7 +1361,7 @@ createNewMultiAllocaWithoutSlot(const MemorySlot &slot, OpBuilder &builder, OpBuilder::InsertionGuard guard(builder); builder.setInsertionPoint(oldOp); auto replacement = - builder.create<TestMultiSlotAlloca>(oldOp->getLoc(), newTypes); + TestMultiSlotAlloca::create(builder, oldOp->getLoc(), newTypes); for (auto [oldResult, newResult] : llvm::zip_equal(remainingValues, replacement.getResults())) oldResult.replaceAllUsesWith(newResult); @@ -1384,7 +1410,7 @@ DenseMap<Attribute, MemorySlot> TestMultiSlotAlloca::destructure( for (Attribute usedIndex : usedIndices) { Type elemType = slot.subelementTypes.lookup(usedIndex); MemRefType elemPtr = MemRefType::get({}, elemType); - auto subAlloca = builder.create<TestMultiSlotAlloca>(getLoc(), elemPtr); + auto subAlloca = TestMultiSlotAlloca::create(builder, getLoc(), elemPtr); newAllocators.push_back(subAlloca); slotMap.try_emplace<MemorySlot>(usedIndex, {subAlloca.getResult(0), elemType}); @@ -1412,8 +1438,8 @@ TestMultiSlotAlloca::handleDestructuringComplete( const auto bufferizedOutType = test::TestMemrefType::get( getContext(), outType.getShape(), outType.getElementType(), nullptr); // replace op with memref analogy - auto dummyMemrefOp = rewriter.create<test::TestDummyMemrefOp>( - getLoc(), bufferizedOutType, *buffer); + auto dummyMemrefOp = test::TestDummyMemrefOp::create( + rewriter, getLoc(), bufferizedOutType, *buffer); mlir::bufferization::replaceOpWithBufferizedValues(rewriter, getOperation(), dummyMemrefOp.getResult()); @@ -1434,7 +1460,7 @@ TestMultiSlotAlloca::handleDestructuringComplete( // replace op with memref analogy auto createMemrefOp = - rewriter.create<test::TestCreateMemrefOp>(getLoc(), *bufferizedOutType); + test::TestCreateMemrefOp::create(rewriter, getLoc(), *bufferizedOutType); mlir::bufferization::replaceOpWithBufferizedValues( rewriter, getOperation(), createMemrefOp.getResult()); diff --git a/mlir/test/lib/Dialect/Test/TestOps.td b/mlir/test/lib/Dialect/Test/TestOps.td index ab3f847..2eaad55 100644 --- a/mlir/test/lib/Dialect/Test/TestOps.td +++ b/mlir/test/lib/Dialect/Test/TestOps.td @@ -119,12 +119,28 @@ def SymbolOp : TEST_Op<"symbol", [NoMemoryEffect, Symbol]> { OptionalAttr<StrAttr>:$sym_visibility); } +def OverriddenSymbolVisibilityOp : TEST_Op<"overridden_symbol_visibility", [ + DeclareOpInterfaceMethods<Symbol, ["getVisibility", "setVisibility"]>, +]> { + let summary = "operation overridden symbol visibility accessors"; + let arguments = (ins StrAttr:$sym_name); +} + def SymbolScopeOp : TEST_Op<"symbol_scope", [SymbolTable, SingleBlockImplicitTerminator<"TerminatorOp">]> { let summary = "operation which defines a new symbol table"; let regions = (region SizedRegion<1>:$region); } +def SymbolScopeIsolatedOp + : TEST_Op<"symbol_scope_isolated", [IsolatedFromAbove, SymbolTable, + SingleBlockImplicitTerminator< + "TerminatorOp">]> { + let summary = + "operation which defines a new symbol table that is IsolatedFromAbove"; + let regions = (region SizedRegion<1>:$region); +} + def SymbolTableRegionOp : TEST_Op<"symbol_table_region", [SymbolTable]> { let summary = "operation which defines a new symbol table without a " "restriction on a terminator"; @@ -2035,7 +2051,7 @@ def IllegalOpWithRegion : TEST_Op<"illegal_op_with_region"> { OpBuilder::InsertionGuard g($_builder); Block *body = $_builder.createBlock(bodyRegion); $_builder.setInsertionPointToEnd(body); - $_builder.create<IllegalOpTerminator>($_state.location); + IllegalOpTerminator::create($_builder,$_state.location); }]>]; } def IllegalOpWithRegionAnchor : TEST_Op<"illegal_op_with_region_anchor">; @@ -2738,7 +2754,7 @@ def TestLinalgConvOp : static void regionBuilder(mlir::ImplicitLocOpBuilder &b, mlir::Block &block, mlir::ArrayRef<mlir::NamedAttribute> attrs, llvm::function_ref<mlir::InFlightDiagnostic()> emitError) { - b.create<mlir::linalg::YieldOp>(block.getArguments().back()); + mlir::linalg::YieldOp::create(b,block.getArguments().back()); } static std::function<void(mlir::ImplicitLocOpBuilder &, mlir::Block &, @@ -2801,7 +2817,7 @@ def TestLinalgFillOp : static void regionBuilder(mlir::ImplicitLocOpBuilder &b, mlir::Block &block, mlir::ArrayRef<mlir::NamedAttribute> attrs, llvm::function_ref<mlir::InFlightDiagnostic()> emitError) { - b.create<mlir::linalg::YieldOp>(block.getArguments().back()); + mlir::linalg::YieldOp::create(b,block.getArguments().back()); } static std::function<void(mlir::ImplicitLocOpBuilder &, mlir::Block &, diff --git a/mlir/test/lib/Dialect/Test/TestOpsSyntax.cpp b/mlir/test/lib/Dialect/Test/TestOpsSyntax.cpp index 6d4e5e3..cc131ad 100644 --- a/mlir/test/lib/Dialect/Test/TestOpsSyntax.cpp +++ b/mlir/test/lib/Dialect/Test/TestOpsSyntax.cpp @@ -313,7 +313,7 @@ ParseResult WrappingRegionOp::parse(OpAsmParser &parser, SmallVector<Value, 8> returnOperands(wrappedOp->getResults()); OpBuilder builder(parser.getContext()); builder.setInsertionPointToEnd(&block); - builder.create<TestReturnOp>(wrappedOp->getLoc(), returnOperands); + TestReturnOp::create(builder, wrappedOp->getLoc(), returnOperands); // Get the results type for the wrapping op from the terminator operands. Operation &returnOp = body.back().back(); @@ -397,7 +397,7 @@ ParseResult PrettyPrintedRegionOp::parse(OpAsmParser &parser, builder.create(opLoc, innerOpName, /*operands=*/{lhs, rhs}, innerOpType); // Insert a return statement in the block returning the inner-op's result. - builder.create<TestReturnOp>(innerOp->getLoc(), innerOp->getResults()); + TestReturnOp::create(builder, innerOp->getLoc(), innerOp->getResults()); // Populate the op operation-state with result-type and location. result.addTypes(opFntype.getResults()); diff --git a/mlir/test/lib/Dialect/Test/TestPatterns.cpp b/mlir/test/lib/Dialect/Test/TestPatterns.cpp index 1fff57e..eda618f 100644 --- a/mlir/test/lib/Dialect/Test/TestPatterns.cpp +++ b/mlir/test/lib/Dialect/Test/TestPatterns.cpp @@ -33,14 +33,14 @@ static Value chooseOperand(Value input1, Value input2, BoolAttr choice) { } static void createOpI(PatternRewriter &rewriter, Location loc, Value input) { - rewriter.create<OpI>(loc, input); + OpI::create(rewriter, loc, input); } static void handleNoResultOp(PatternRewriter &rewriter, OpSymbolBindingNoResult op) { // Turn the no result op to a one-result op. - rewriter.create<OpSymbolBindingB>(op.getLoc(), op.getOperand().getType(), - op.getOperand()); + OpSymbolBindingB::create(rewriter, op.getLoc(), op.getOperand().getType(), + op.getOperand()); } static bool getFirstI32Result(Operation *op, Value &value) { @@ -120,8 +120,8 @@ public: return failure(); rewriter.setInsertionPointToStart(op->getBlock()); - auto constOp = rewriter.create<arith::ConstantOp>( - op.getLoc(), rewriter.getBoolAttr(true)); + auto constOp = arith::ConstantOp::create(rewriter, op.getLoc(), + rewriter.getBoolAttr(true)); rewriter.replaceOpWithNewOp<TestCastOp>(op, rewriter.getI32Type(), Value(constOp)); return success(); @@ -844,8 +844,8 @@ struct TestRegionRewriteUndo : public RewritePattern { rewriter.getUnknownLoc()); // Add an explicitly illegal operation to ensure the conversion fails. - rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getIntegerType(32)); - rewriter.create<TestValidOp>(op->getLoc(), ArrayRef<Value>()); + ILLegalOpF::create(rewriter, op->getLoc(), rewriter.getIntegerType(32)); + TestValidOp::create(rewriter, op->getLoc(), ArrayRef<Value>()); // Drop this operation. rewriter.eraseOp(op); @@ -864,7 +864,7 @@ struct TestCreateBlock : public RewritePattern { Type i32Type = rewriter.getIntegerType(32); Location loc = op->getLoc(); rewriter.createBlock(®ion, region.end(), {i32Type, i32Type}, {loc, loc}); - rewriter.create<TerminatorOp>(loc); + TerminatorOp::create(rewriter, loc); rewriter.eraseOp(op); return success(); } @@ -883,8 +883,8 @@ struct TestCreateIllegalBlock : public RewritePattern { Location loc = op->getLoc(); rewriter.createBlock(®ion, region.end(), {i32Type, i32Type}, {loc, loc}); // Create an illegal op to ensure the conversion fails. - rewriter.create<ILLegalOpF>(loc, i32Type); - rewriter.create<TerminatorOp>(loc); + ILLegalOpF::create(rewriter, loc, i32Type); + TerminatorOp::create(rewriter, loc); rewriter.eraseOp(op); return success(); } @@ -939,7 +939,7 @@ struct TestUndoBlockErase : public ConversionPattern { ConversionPatternRewriter &rewriter) const final { Block *secondBlock = &*std::next(op->getRegion(0).begin()); rewriter.setInsertionPointToStart(secondBlock); - rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type()); + ILLegalOpF::create(rewriter, op->getLoc(), rewriter.getF32Type()); rewriter.eraseBlock(secondBlock); rewriter.modifyOpInPlace(op, [] {}); return success(); @@ -1007,9 +1007,8 @@ struct TestPassthroughInvalidOp : public ConversionPattern { // This is a 1:N replacement. Insert a test.cast op. (That's what the // argument materialization used to do.) flattened.push_back( - rewriter - .create<TestCastOp>(op->getLoc(), - op->getOperand(it.index()).getType(), range) + TestCastOp::create(rewriter, op->getLoc(), + op->getOperand(it.index()).getType(), range) .getResult()); } rewriter.replaceOpWithNewOp<TestValidOp>(op, TypeRange(), flattened, @@ -1114,8 +1113,8 @@ struct TestNonRootReplacement : public RewritePattern { LogicalResult matchAndRewrite(Operation *op, PatternRewriter &rewriter) const final { auto resultType = *op->result_type_begin(); - auto illegalOp = rewriter.create<ILLegalOpF>(op->getLoc(), resultType); - auto legalOp = rewriter.create<LegalOpB>(op->getLoc(), resultType); + auto illegalOp = ILLegalOpF::create(rewriter, op->getLoc(), resultType); + auto legalOp = LegalOpB::create(rewriter, op->getLoc(), resultType); rewriter.replaceOp(illegalOp, legalOp); rewriter.replaceOp(op, illegalOp); @@ -1181,7 +1180,7 @@ struct TestCreateUnregisteredOp : public OpRewritePattern<ILLegalOpG> { LogicalResult matchAndRewrite(ILLegalOpG op, PatternRewriter &rewriter) const final { IntegerAttr attr = rewriter.getI32IntegerAttr(0); - Value val = rewriter.create<arith::ConstantOp>(op->getLoc(), attr); + Value val = arith::ConstantOp::create(rewriter, op->getLoc(), attr); rewriter.replaceOpWithNewOp<LegalOpC>(op, val); return success(); }; @@ -1354,7 +1353,7 @@ struct TestTypeConverter : public TypeConverter { /// 1->N type mappings. static Value materializeCast(OpBuilder &builder, Type resultType, ValueRange inputs, Location loc) { - return builder.create<TestCastOp>(loc, resultType, inputs).getResult(); + return TestCastOp::create(builder, loc, resultType, inputs).getResult(); } }; @@ -1362,6 +1361,10 @@ struct TestLegalizePatternDriver : public PassWrapper<TestLegalizePatternDriver, OperationPass<>> { MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLegalizePatternDriver) + TestLegalizePatternDriver() = default; + TestLegalizePatternDriver(const TestLegalizePatternDriver &other) + : PassWrapper(other) {} + StringRef getArgument() const final { return "test-legalize-patterns"; } StringRef getDescription() const final { return "Run test dialect legalization patterns"; @@ -1369,8 +1372,6 @@ struct TestLegalizePatternDriver /// The mode of conversion to use with the driver. enum class ConversionMode { Analysis, Full, Partial }; - TestLegalizePatternDriver(ConversionMode mode) : mode(mode) {} - void getDependentDialects(DialectRegistry ®istry) const override { registry.insert<func::FuncDialect, test::TestDialect>(); } @@ -1499,24 +1500,19 @@ struct TestLegalizePatternDriver op->emitRemark() << "op '" << op->getName() << "' is legalizable"; } - /// The mode of conversion to use. - ConversionMode mode; + Option<ConversionMode> mode{ + *this, "test-legalize-mode", + llvm::cl::desc("The legalization mode to use with the test driver"), + llvm::cl::init(ConversionMode::Partial), + llvm::cl::values( + clEnumValN(ConversionMode::Analysis, "analysis", + "Perform an analysis conversion"), + clEnumValN(ConversionMode::Full, "full", "Perform a full conversion"), + clEnumValN(ConversionMode::Partial, "partial", + "Perform a partial conversion"))}; }; } // namespace -static llvm::cl::opt<TestLegalizePatternDriver::ConversionMode> - legalizerConversionMode( - "test-legalize-mode", - llvm::cl::desc("The legalization mode to use with the test driver"), - llvm::cl::init(TestLegalizePatternDriver::ConversionMode::Partial), - llvm::cl::values( - clEnumValN(TestLegalizePatternDriver::ConversionMode::Analysis, - "analysis", "Perform an analysis conversion"), - clEnumValN(TestLegalizePatternDriver::ConversionMode::Full, "full", - "Perform a full conversion"), - clEnumValN(TestLegalizePatternDriver::ConversionMode::Partial, - "partial", "Perform a partial conversion"))); - //===----------------------------------------------------------------------===// // ConversionPatternRewriter::getRemappedValue testing. This method is used // to get the remapped value of an original value that was replaced using @@ -1916,15 +1912,15 @@ struct TestTypeConversionDriver // Allow casting from F64 back to F32. if (!resultType.isF16() && inputs.size() == 1 && inputs[0].getType().isF64()) - return builder.create<TestCastOp>(loc, resultType, inputs).getResult(); + return TestCastOp::create(builder, loc, resultType, inputs).getResult(); // Allow producing an i32 or i64 from nothing. if ((resultType.isInteger(32) || resultType.isInteger(64)) && inputs.empty()) - return builder.create<TestTypeProducerOp>(loc, resultType); + return TestTypeProducerOp::create(builder, loc, resultType); // Allow producing an i64 from an integer. if (isa<IntegerType>(resultType) && inputs.size() == 1 && isa<IntegerType>(inputs[0].getType())) - return builder.create<TestCastOp>(loc, resultType, inputs).getResult(); + return TestCastOp::create(builder, loc, resultType, inputs).getResult(); // Otherwise, fail. return nullptr; }); @@ -2007,7 +2003,7 @@ struct TestTargetMaterializationWithNoUses }); converter.addTargetMaterialization( [](OpBuilder &builder, Type type, ValueRange inputs, Location loc) { - return builder.create<TestCastOp>(loc, type, inputs).getResult(); + return TestCastOp::create(builder, loc, type, inputs).getResult(); }); ConversionTarget target(getContext()); @@ -2058,7 +2054,7 @@ struct TestUndoBlocksMerge : public ConversionPattern { Operation *branchOp = firstBlock.getTerminator(); Block *secondBlock = &*(std::next(op->getRegion(0).begin())); rewriter.setInsertionPointToStart(secondBlock); - rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getF32Type()); + ILLegalOpF::create(rewriter, op->getLoc(), rewriter.getF32Type()); auto succOperands = branchOp->getOperands(); SmallVector<Value, 2> replacements(succOperands); rewriter.eraseOp(branchOp); @@ -2202,9 +2198,7 @@ void registerPatternsTestPass() { PassRegistration<TestStrictPatternDriver>(); PassRegistration<TestWalkPatternDriver>(); - PassRegistration<TestLegalizePatternDriver>([] { - return std::make_unique<TestLegalizePatternDriver>(legalizerConversionMode); - }); + PassRegistration<TestLegalizePatternDriver>(); PassRegistration<TestRemappedValue>(); diff --git a/mlir/test/lib/Dialect/Test/TestToLLVMIRTranslation.cpp b/mlir/test/lib/Dialect/Test/TestToLLVMIRTranslation.cpp index 103817d..7831b27 100644 --- a/mlir/test/lib/Dialect/Test/TestToLLVMIRTranslation.cpp +++ b/mlir/test/lib/Dialect/Test/TestToLLVMIRTranslation.cpp @@ -68,8 +68,8 @@ LogicalResult TestDialectLLVMIRTranslationInterface::amendOperation( if (createSymbol) { OpBuilder builder(op->getRegion(0)); - builder.create<test::SymbolOp>( - op->getLoc(), + test::SymbolOp::create( + builder, op->getLoc(), StringAttr::get(op->getContext(), "sym_from_attr"), /*sym_visibility=*/nullptr); } diff --git a/mlir/test/lib/Dialect/TestIRDLToCpp/TestIRDLToCppDialect.cpp b/mlir/test/lib/Dialect/TestIRDLToCpp/TestIRDLToCppDialect.cpp index bda614a..9550e4c 100644 --- a/mlir/test/lib/Dialect/TestIRDLToCpp/TestIRDLToCppDialect.cpp +++ b/mlir/test/lib/Dialect/TestIRDLToCpp/TestIRDLToCppDialect.cpp @@ -47,9 +47,9 @@ struct TestOpConversion : public OpConversionPattern<test_irdl_to_cpp::BeefOp> { op, op->getResultTypes().front()); rewriter.setInsertionPointAfter(bar); - rewriter.create<test_irdl_to_cpp::HashOp>( - bar.getLoc(), rewriter.getIntegerType(32), adaptor.getLhs(), - adaptor.getRhs()); + test_irdl_to_cpp::HashOp::create(rewriter, bar.getLoc(), + rewriter.getIntegerType(32), + adaptor.getLhs(), adaptor.getRhs()); return success(); } }; diff --git a/mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp b/mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp index 3389a1c..6457487 100644 --- a/mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp +++ b/mlir/test/lib/Dialect/Tosa/TosaTestPasses.cpp @@ -87,9 +87,9 @@ ConvertTosaNegateOp::matchAndRewrite(Operation *op, return failure(); auto newConstOp = - rewriter.create<tosa::ConstOp>(op->getLoc(), dstQConstType, inputElems); - auto newNegateOp = rewriter.create<tosa::NegateOp>( - op->getLoc(), dstQConstType, newConstOp.getResult()); + tosa::ConstOp::create(rewriter, op->getLoc(), dstQConstType, inputElems); + auto newNegateOp = tosa::NegateOp::create( + rewriter, op->getLoc(), dstQConstType, newConstOp.getResult()); rewriter.replaceOp(op, {newNegateOp.getResult()}); return success(); @@ -145,8 +145,8 @@ ConvertTosaConv2DOp::matchAndRewrite(Operation *op, auto newTosaConv2DOpType = RankedTensorType::get(outputType.getShape(), rewriter.getIntegerType(32)); - auto newTosaConv2DOp = rewriter.create<tosa::Conv2DOp>( - op->getLoc(), newTosaConv2DOpType, tosaConv2DOp.getInput(), + auto newTosaConv2DOp = tosa::Conv2DOp::create( + rewriter, op->getLoc(), newTosaConv2DOpType, tosaConv2DOp.getInput(), tosaConv2DOp.getWeight(), tosaConv2DOp.getBias(), tosaConv2DOp.getPadAttr(), tosaConv2DOp.getStrideAttr(), tosaConv2DOp.getDilationAttr(), tosaConv2DOp.getAccTypeAttr()); @@ -178,8 +178,8 @@ ConvertTosaConv2DOp::matchAndRewrite(Operation *op, newTosaConv2DOp.getResult().getType().isUnsignedInteger(); bool outputUnsigned = outputType.isUnsignedInteger(); - auto newTosaRescaleOp = rewriter.create<tosa::RescaleOp>( - op->getLoc(), outputType, newTosaConv2DOp.getResult(), + auto newTosaRescaleOp = tosa::RescaleOp::create( + rewriter, op->getLoc(), outputType, newTosaConv2DOp.getResult(), getConstTensorInt<int32_t>(rewriter, op->getLoc(), {multiplier}), getConstTensorInt<int8_t>(rewriter, op->getLoc(), {static_cast<int8_t>(shift)}), diff --git a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp index cdf44c2..97fc699 100644 --- a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp +++ b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp @@ -796,8 +796,8 @@ DiagnosedSilenceableFailure mlir::test::TestProduceInvalidIR::applyToOne( transform::TransformState &state) { // Provide some IR that does not verify. rewriter.setInsertionPointToStart(&target->getRegion(0).front()); - rewriter.create<TestDummyPayloadOp>(target->getLoc(), TypeRange(), - ValueRange(), /*failToVerify=*/true); + TestDummyPayloadOp::create(rewriter, target->getLoc(), TypeRange(), + ValueRange(), /*failToVerify=*/true); return DiagnosedSilenceableFailure::success(); } @@ -877,7 +877,8 @@ public: Location loc) -> Value { if (inputs.size() != 1) return Value(); - return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs) + return UnrealizedConversionCastOp::create(builder, loc, resultType, + inputs) .getResult(0); }; addSourceMaterialization(unrealizedCastConverter); diff --git a/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp b/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp index a7285ab..f89c944 100644 --- a/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp +++ b/mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp @@ -546,8 +546,8 @@ static Value allocateGlobalSharedMemory(Location loc, OpBuilder &builder, auto ip = builder.saveInsertionPoint(); builder.setInsertionPoint(moduleOp); - auto global = builder.create<memref::GlobalOp>( - loc, + auto global = memref::GlobalOp::create( + builder, loc, /*sym_name=*/symbolName, /*sym_visibility=*/builder.getStringAttr("private"), /*type=*/memrefType, @@ -560,19 +560,18 @@ static Value allocateGlobalSharedMemory(Location loc, OpBuilder &builder, global->moveBefore(&moduleOp.front()); builder.restoreInsertionPoint(ip); - return builder.create<memref::GetGlobalOp>(loc, memrefType, symbolName); + return memref::GetGlobalOp::create(builder, loc, memrefType, symbolName); } static Value warpReduction(Location loc, OpBuilder &builder, Value input, CombiningKind kind, uint32_t size) { // First reduce on a single thread to get per lane reduction value. - Value laneVal = builder.create<vector::ReductionOp>(loc, kind, input); + Value laneVal = vector::ReductionOp::create(builder, loc, kind, input); // Parallel reduction using butterfly shuffles. for (uint64_t i = 1; i < size; i <<= 1) { - Value shuffled = builder - .create<gpu::ShuffleOp>(loc, laneVal, i, - /*width=*/size, - /*mode=*/gpu::ShuffleMode::XOR) + Value shuffled = gpu::ShuffleOp::create(builder, loc, laneVal, i, + /*width=*/size, + /*mode=*/gpu::ShuffleMode::XOR) .getShuffleResult(); laneVal = makeArithReduction(builder, loc, kind, laneVal, shuffled); } @@ -647,12 +646,11 @@ struct TestVectorDistribution "unsupported shuffle type"); Type i32Type = builder.getIntegerType(32); Value srcIdxI32 = - builder.create<arith::IndexCastOp>(loc, i32Type, srcIdx); - Value warpSzI32 = builder.create<arith::ConstantOp>( - loc, builder.getIntegerAttr(i32Type, warpSz)); - Value result = builder - .create<gpu::ShuffleOp>(loc, val, srcIdxI32, warpSzI32, - gpu::ShuffleMode::IDX) + arith::IndexCastOp::create(builder, loc, i32Type, srcIdx); + Value warpSzI32 = arith::ConstantOp::create( + builder, loc, builder.getIntegerAttr(i32Type, warpSz)); + Value result = gpu::ShuffleOp::create(builder, loc, val, srcIdxI32, + warpSzI32, gpu::ShuffleMode::IDX) .getResult(0); return result; }; @@ -680,7 +678,7 @@ struct TestVectorDistribution options.warpAllocationFn = allocateGlobalSharedMemory; options.warpSyncronizationFn = [](Location loc, OpBuilder &builder, gpu::WarpExecuteOnLane0Op warpOp) { - builder.create<gpu::BarrierOp>(loc); + gpu::BarrierOp::create(builder, loc); }; // Test on one pattern in isolation. if (warpOpToSCF) { diff --git a/mlir/test/lib/Dialect/XeGPU/TestXeGPUTransforms.cpp b/mlir/test/lib/Dialect/XeGPU/TestXeGPUTransforms.cpp index f71fcf7..c6245b6 100644 --- a/mlir/test/lib/Dialect/XeGPU/TestXeGPUTransforms.cpp +++ b/mlir/test/lib/Dialect/XeGPU/TestXeGPUTransforms.cpp @@ -20,8 +20,6 @@ using namespace mlir::xegpu; namespace { #define DEBUG_TYPE "test-xegpu-unroll" -#define DBGS() (llvm::dbgs() << "[" DEBUG_TYPE "]: ") -#define LDBG(X) LLVM_DEBUG(DBGS() << X << "\n") struct TestXeGPUUnrollingPatterns : public PassWrapper<TestXeGPUUnrollingPatterns, diff --git a/mlir/test/lib/IR/TestPrintInvalid.cpp b/mlir/test/lib/IR/TestPrintInvalid.cpp index 8697918..25d1b19 100644 --- a/mlir/test/lib/IR/TestPrintInvalid.cpp +++ b/mlir/test/lib/IR/TestPrintInvalid.cpp @@ -34,13 +34,14 @@ struct TestPrintInvalidPass void runOnOperation() override { Location loc = getOperation().getLoc(); OpBuilder builder(getOperation().getBodyRegion()); - auto funcOp = builder.create<func::FuncOp>( - loc, "test", FunctionType::get(getOperation().getContext(), {}, {})); + auto funcOp = func::FuncOp::create( + builder, loc, "test", + FunctionType::get(getOperation().getContext(), {}, {})); funcOp.addEntryBlock(); // The created function is invalid because there is no return op. llvm::outs() << "Invalid operation:\n" << funcOp << "\n"; builder.setInsertionPointToEnd(&funcOp.getBody().front()); - builder.create<func::ReturnOp>(loc); + func::ReturnOp::create(builder, loc); // Now this function is valid. llvm::outs() << "Valid operation:\n" << funcOp << "\n"; funcOp.erase(); diff --git a/mlir/test/lib/IR/TestSlicing.cpp b/mlir/test/lib/IR/TestSlicing.cpp index 92fd6de..5a5ac45 100644 --- a/mlir/test/lib/IR/TestSlicing.cpp +++ b/mlir/test/lib/IR/TestSlicing.cpp @@ -30,8 +30,8 @@ static LogicalResult createBackwardSliceFunction(Operation *op, OpBuilder builder(parentFuncOp); Location loc = op->getLoc(); std::string clonedFuncOpName = parentFuncOp.getName().str() + suffix.str(); - func::FuncOp clonedFuncOp = builder.create<func::FuncOp>( - loc, clonedFuncOpName, parentFuncOp.getFunctionType()); + func::FuncOp clonedFuncOp = func::FuncOp::create( + builder, loc, clonedFuncOpName, parentFuncOp.getFunctionType()); IRMapping mapper; builder.setInsertionPointToEnd(clonedFuncOp.addEntryBlock()); for (const auto &arg : enumerate(parentFuncOp.getArguments())) @@ -46,7 +46,7 @@ static LogicalResult createBackwardSliceFunction(Operation *op, (void)result; for (Operation *slicedOp : slice) builder.clone(*slicedOp, mapper); - builder.create<func::ReturnOp>(loc); + func::ReturnOp::create(builder, loc); return success(); } diff --git a/mlir/test/lib/Pass/TestPassManager.cpp b/mlir/test/lib/Pass/TestPassManager.cpp index 7afe210..25c8e53 100644 --- a/mlir/test/lib/Pass/TestPassManager.cpp +++ b/mlir/test/lib/Pass/TestPassManager.cpp @@ -217,8 +217,8 @@ struct TestInvalidParentPass void runOnOperation() final { FunctionOpInterface op = getOperation(); OpBuilder b(op.getFunctionBody()); - b.create<test::TestCallOp>(op.getLoc(), TypeRange(), "some_unknown_func", - ValueRange()); + test::TestCallOp::create(b, op.getLoc(), TypeRange(), "some_unknown_func", + ValueRange()); } }; diff --git a/mlir/test/lib/Transforms/TestDialectConversion.cpp b/mlir/test/lib/Transforms/TestDialectConversion.cpp index 8278937..dc0538e 100644 --- a/mlir/test/lib/Transforms/TestDialectConversion.cpp +++ b/mlir/test/lib/Transforms/TestDialectConversion.cpp @@ -45,7 +45,7 @@ struct PDLLTypeConverter : public TypeConverter { /// Hook for materializing a conversion. static Value materializeCast(OpBuilder &builder, Type resultType, ValueRange inputs, Location loc) { - return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs) + return UnrealizedConversionCastOp::create(builder, loc, resultType, inputs) .getResult(0); } }; diff --git a/mlir/test/lib/Transforms/TestInliningCallback.cpp b/mlir/test/lib/Transforms/TestInliningCallback.cpp index c518f3f..2888c3c 100644 --- a/mlir/test/lib/Transforms/TestInliningCallback.cpp +++ b/mlir/test/lib/Transforms/TestInliningCallback.cpp @@ -53,8 +53,8 @@ struct InlinerCallback mlir::Operation &call = inlineBlock->back(); builder.setInsertionPointAfter(&call); - auto executeRegionOp = builder.create<mlir::scf::ExecuteRegionOp>( - call.getLoc(), call.getResultTypes()); + auto executeRegionOp = mlir::scf::ExecuteRegionOp::create( + builder, call.getLoc(), call.getResultTypes()); mlir::Region ®ion = executeRegionOp.getRegion(); // Move the inlined blocks into the region @@ -70,8 +70,8 @@ struct InlinerCallback if (test::TestReturnOp returnOp = llvm::dyn_cast<test::TestReturnOp>(&op)) { mlir::OpBuilder returnBuilder(returnOp); - returnBuilder.create<mlir::scf::YieldOp>(returnOp.getLoc(), - returnOp.getOperands()); + mlir::scf::YieldOp::create(returnBuilder, returnOp.getLoc(), + returnOp.getOperands()); returnOp.erase(); } } @@ -79,8 +79,8 @@ struct InlinerCallback // Add test.return after scf.execute_region builder.setInsertionPointAfter(executeRegionOp); - builder.create<test::TestReturnOp>(executeRegionOp.getLoc(), - executeRegionOp.getResults()); + test::TestReturnOp::create(builder, executeRegionOp.getLoc(), + executeRegionOp.getResults()); } void runOnOperation() override { diff --git a/mlir/test/lib/Transforms/TestMakeIsolatedFromAbove.cpp b/mlir/test/lib/Transforms/TestMakeIsolatedFromAbove.cpp index 4e0213c..c1fb706 100644 --- a/mlir/test/lib/Transforms/TestMakeIsolatedFromAbove.cpp +++ b/mlir/test/lib/Transforms/TestMakeIsolatedFromAbove.cpp @@ -28,7 +28,7 @@ makeIsolatedFromAboveImpl(RewriterBase &rewriter, SmallVector<Value> operands = regionOp.getOperands(); operands.append(capturedValues); auto isolatedRegionOp = - rewriter.create<test::IsolatedOneRegionOp>(regionOp.getLoc(), operands); + test::IsolatedOneRegionOp::create(rewriter, regionOp.getLoc(), operands); rewriter.inlineRegionBefore(region, isolatedRegionOp.getRegion(), isolatedRegionOp.getRegion().begin()); rewriter.eraseOp(regionOp); diff --git a/mlir/test/lib/Transforms/TestTransformsOps.cpp b/mlir/test/lib/Transforms/TestTransformsOps.cpp index 9a5632b..ff5838d 100644 --- a/mlir/test/lib/Transforms/TestTransformsOps.cpp +++ b/mlir/test/lib/Transforms/TestTransformsOps.cpp @@ -74,8 +74,8 @@ transform::TestMakeComposedFoldedAffineApply::applyToOne( if (auto v = dyn_cast<Value>(ofr)) { result = v; } else { - result = rewriter.create<arith::ConstantIndexOp>( - loc, getConstantIntValue(ofr).value()); + result = arith::ConstantIndexOp::create(rewriter, loc, + getConstantIntValue(ofr).value()); } results.push_back(result.getDefiningOp()); rewriter.replaceOp(affineApplyOp, result); |