Author: Rahul Joshi Date: 2020-12-10T09:33:43-08:00 New Revision: 563879b6f9465982b422a69a901e3d84e7cb7764
URL: https://github.com/llvm/llvm-project/commit/563879b6f9465982b422a69a901e3d84e7cb7764 DIFF: https://github.com/llvm/llvm-project/commit/563879b6f9465982b422a69a901e3d84e7cb7764.diff LOG: [NFC] Use ConvertOpToLLVMPattern instead of ConvertToLLVMPattern. - use ConvertOpToLLVMPattern to avoid explicit casting and in most cases the constructor can be reused to save a few lines of code. Differential Revision: https://reviews.llvm.org/D92989 Added: Modified: mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp Removed: ################################################################################ diff --git a/mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h b/mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h index b7c9d0016d65..948c2a4be6f2 100644 --- a/mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h +++ b/mlir/include/mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h @@ -18,8 +18,7 @@ template <typename T> class OperationPass; /// Populate the given list with patterns that convert from Linalg to LLVM. void populateLinalgToLLVMConversionPatterns(LLVMTypeConverter &converter, - OwningRewritePatternList &patterns, - MLIRContext *ctx); + OwningRewritePatternList &patterns); /// Create a pass to convert Linalg operations to the LLVMIR dialect. std::unique_ptr<OperationPass<ModuleOp>> createConvertLinalgToLLVMPass(); diff --git a/mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h b/mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h index ace07ac7223b..4eae84cd0135 100644 --- a/mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h +++ b/mlir/include/mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h @@ -19,8 +19,7 @@ class OperationPass; class OwningRewritePatternList; /// Populate the given list with patterns that convert from OpenMP to LLVM. -void populateOpenMPToLLVMConversionPatterns(MLIRContext *context, - LLVMTypeConverter &converter, +void populateOpenMPToLLVMConversionPatterns(LLVMTypeConverter &converter, OwningRewritePatternList &patterns); /// Create a pass to convert OpenMP operations to the LLVMIR dialect. diff --git a/mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h b/mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h index bf41f29749de..7c069c9cd556 100644 --- a/mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h +++ b/mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h @@ -565,8 +565,8 @@ class ConvertToLLVMPattern : public ConversionPattern { template <typename SourceOp> class ConvertOpToLLVMPattern : public ConvertToLLVMPattern { public: - ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter, - PatternBenefit benefit = 1) + explicit ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter, + PatternBenefit benefit = 1) : ConvertToLLVMPattern(SourceOp::getOperationName(), &typeConverter.getContext(), typeConverter, benefit) {} diff --git a/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp b/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp index fe06e12c8f21..06a19b057f71 100644 --- a/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp +++ b/mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp @@ -34,8 +34,7 @@ static Type getSrcVectorElementType(OpTy op) { /// operands as is, preserve attributes. template <typename SourceOp, typename TargetOp> static LogicalResult -matchAndRewriteOneToOne(const ConvertToLLVMPattern &lowering, - LLVMTypeConverter &typeConverter, Operation *op, +matchAndRewriteOneToOne(LLVMTypeConverter &typeConverter, Operation *op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) { unsigned numResults = op->getNumResults(); @@ -73,71 +72,61 @@ namespace { // TODO: Patterns are too verbose due to the fact that we have 1 op (e.g. // MaskRndScaleOp) and diff erent possible target ops. It would be better to take // a Functor so that all these conversions become 1-liners. -struct MaskRndScaleOpPS512Conversion : public ConvertToLLVMPattern { - explicit MaskRndScaleOpPS512Conversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(MaskRndScaleOp::getOperationName(), context, - typeConverter) {} +struct MaskRndScaleOpPS512Conversion + : public ConvertOpToLLVMPattern<MaskRndScaleOp> { + using ConvertOpToLLVMPattern<MaskRndScaleOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(MaskRndScaleOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - if (!getSrcVectorElementType(cast<MaskRndScaleOp>(op)).isF32()) + if (!getSrcVectorElementType(op).isF32()) return failure(); return matchAndRewriteOneToOne<MaskRndScaleOp, LLVM::x86_avx512_mask_rndscale_ps_512>( - *this, *getTypeConverter(), op, operands, rewriter); + *getTypeConverter(), op, operands, rewriter); } }; -struct MaskRndScaleOpPD512Conversion : public ConvertToLLVMPattern { - explicit MaskRndScaleOpPD512Conversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(MaskRndScaleOp::getOperationName(), context, - typeConverter) {} +struct MaskRndScaleOpPD512Conversion + : public ConvertOpToLLVMPattern<MaskRndScaleOp> { + using ConvertOpToLLVMPattern<MaskRndScaleOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(MaskRndScaleOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - if (!getSrcVectorElementType(cast<MaskRndScaleOp>(op)).isF64()) + if (!getSrcVectorElementType(op).isF64()) return failure(); return matchAndRewriteOneToOne<MaskRndScaleOp, LLVM::x86_avx512_mask_rndscale_pd_512>( - *this, *getTypeConverter(), op, operands, rewriter); + *getTypeConverter(), op, operands, rewriter); } }; -struct ScaleFOpPS512Conversion : public ConvertToLLVMPattern { - explicit ScaleFOpPS512Conversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(MaskScaleFOp::getOperationName(), context, - typeConverter) {} +struct ScaleFOpPS512Conversion : public ConvertOpToLLVMPattern<MaskScaleFOp> { + using ConvertOpToLLVMPattern<MaskScaleFOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(MaskScaleFOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - if (!getSrcVectorElementType(cast<MaskScaleFOp>(op)).isF32()) + if (!getSrcVectorElementType(op).isF32()) return failure(); return matchAndRewriteOneToOne<MaskScaleFOp, LLVM::x86_avx512_mask_scalef_ps_512>( - *this, *getTypeConverter(), op, operands, rewriter); + *getTypeConverter(), op, operands, rewriter); } }; -struct ScaleFOpPD512Conversion : public ConvertToLLVMPattern { - explicit ScaleFOpPD512Conversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(MaskScaleFOp::getOperationName(), context, - typeConverter) {} +struct ScaleFOpPD512Conversion : public ConvertOpToLLVMPattern<MaskScaleFOp> { + using ConvertOpToLLVMPattern<MaskScaleFOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(MaskScaleFOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - if (!getSrcVectorElementType(cast<MaskScaleFOp>(op)).isF64()) + if (!getSrcVectorElementType(op).isF64()) return failure(); return matchAndRewriteOneToOne<MaskScaleFOp, LLVM::x86_avx512_mask_scalef_pd_512>( - *this, *getTypeConverter(), op, operands, rewriter); + *getTypeConverter(), op, operands, rewriter); } }; } // namespace @@ -145,11 +134,10 @@ struct ScaleFOpPD512Conversion : public ConvertToLLVMPattern { /// Populate the given list with patterns that convert from AVX512 to LLVM. void mlir::populateAVX512ToLLVMConversionPatterns( LLVMTypeConverter &converter, OwningRewritePatternList &patterns) { - MLIRContext *ctx = converter.getDialect()->getContext(); // clang-format off patterns.insert<MaskRndScaleOpPS512Conversion, MaskRndScaleOpPD512Conversion, ScaleFOpPS512Conversion, - ScaleFOpPD512Conversion>(ctx, converter); + ScaleFOpPD512Conversion>(converter); // clang-format on } diff --git a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h index 69ea393e5df1..bf17200e594f 100644 --- a/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h +++ b/mlir/lib/Conversion/GPUCommon/GPUOpsLowering.h @@ -18,17 +18,13 @@ namespace mlir { template <unsigned AllocaAddrSpace> -struct GPUFuncOpLowering : ConvertToLLVMPattern { - explicit GPUFuncOpLowering(LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(gpu::GPUFuncOp::getOperationName(), - typeConverter.getDialect()->getContext(), - typeConverter) {} +struct GPUFuncOpLowering : ConvertOpToLLVMPattern<gpu::GPUFuncOp> { + using ConvertOpToLLVMPattern<gpu::GPUFuncOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { assert(operands.empty() && "func op is not expected to have operands"); - auto gpuFuncOp = cast<gpu::GPUFuncOp>(op); Location loc = gpuFuncOp.getLoc(); SmallVector<LLVM::GlobalOp, 3> workgroupBuffers; @@ -154,14 +150,11 @@ struct GPUFuncOpLowering : ConvertToLLVMPattern { } }; -struct GPUReturnOpLowering : public ConvertToLLVMPattern { - GPUReturnOpLowering(LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(gpu::ReturnOp::getOperationName(), - typeConverter.getDialect()->getContext(), - typeConverter) {} +struct GPUReturnOpLowering : public ConvertOpToLLVMPattern<gpu::ReturnOp> { + using ConvertOpToLLVMPattern<gpu::ReturnOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(gpu::ReturnOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands); return success(); diff --git a/mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h b/mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h index f4b7cedeb0e1..a51dff51cac4 100644 --- a/mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h +++ b/mlir/lib/Conversion/GPUCommon/IndexIntrinsicsOpLowering.h @@ -21,7 +21,7 @@ namespace mlir { // `indexBitwidth`, sign-extend or truncate the resulting value to match the // bitwidth expected by the consumers of the value. template <typename Op, typename XOp, typename YOp, typename ZOp> -struct GPUIndexIntrinsicOpLowering : public ConvertToLLVMPattern { +struct GPUIndexIntrinsicOpLowering : public ConvertOpToLLVMPattern<Op> { private: enum dimension { X = 0, Y = 1, Z = 2, invalid }; unsigned indexBitwidth; @@ -36,19 +36,17 @@ struct GPUIndexIntrinsicOpLowering : public ConvertToLLVMPattern { public: explicit GPUIndexIntrinsicOpLowering(LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(Op::getOperationName(), - typeConverter.getDialect()->getContext(), - typeConverter), + : ConvertOpToLLVMPattern<Op>(typeConverter), indexBitwidth(typeConverter.getIndexTypeBitwidth()) {} // Convert the kernel arguments to an LLVM type, preserve the rest. LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(Op op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { auto loc = op->getLoc(); MLIRContext *context = rewriter.getContext(); Value newOp; - switch (dimensionToIndex(cast<Op>(op))) { + switch (dimensionToIndex(op)) { case X: newOp = rewriter.create<XOp>(loc, LLVM::LLVMType::getInt32Ty(context)); break; diff --git a/mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h b/mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h index fc743823fd31..9d08aeee1906 100644 --- a/mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h +++ b/mlir/lib/Conversion/GPUCommon/OpToFuncCallLowering.h @@ -29,16 +29,15 @@ namespace mlir { /// will be transformed into /// llvm.call @__nv_expf(%arg_f32) : (!llvm.float) -> !llvm.float template <typename SourceOp> -struct OpToFuncCallLowering : public ConvertToLLVMPattern { +struct OpToFuncCallLowering : public ConvertOpToLLVMPattern<SourceOp> { public: explicit OpToFuncCallLowering(LLVMTypeConverter &lowering_, StringRef f32Func, StringRef f64Func) - : ConvertToLLVMPattern(SourceOp::getOperationName(), - lowering_.getDialect()->getContext(), lowering_), - f32Func(f32Func), f64Func(f64Func) {} + : ConvertOpToLLVMPattern<SourceOp>(lowering_), f32Func(f32Func), + f64Func(f64Func) {} LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(SourceOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { using LLVM::LLVMFuncOp; using LLVM::LLVMType; diff --git a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp index a0fe48175636..3e90894e2fe9 100644 --- a/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp +++ b/mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp @@ -31,10 +31,8 @@ using namespace mlir; namespace { -struct GPUShuffleOpLowering : public ConvertToLLVMPattern { - explicit GPUShuffleOpLowering(LLVMTypeConverter &lowering_) - : ConvertToLLVMPattern(gpu::ShuffleOp::getOperationName(), - lowering_.getDialect()->getContext(), lowering_) {} +struct GPUShuffleOpLowering : public ConvertOpToLLVMPattern<gpu::ShuffleOp> { + using ConvertOpToLLVMPattern<gpu::ShuffleOp>::ConvertOpToLLVMPattern; /// Lowers a shuffle to the corresponding NVVM op. /// @@ -53,7 +51,7 @@ struct GPUShuffleOpLowering : public ConvertToLLVMPattern { /// %shfl_pred = llvm.extractvalue %shfl[1 : index] : /// !llvm<"{ float, i1 }"> LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(gpu::ShuffleOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { Location loc = op->getLoc(); gpu::ShuffleOpAdaptor adaptor(operands); diff --git a/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp b/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp index b907703995d8..47e8f27ee04a 100644 --- a/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp +++ b/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp @@ -126,19 +126,17 @@ class BaseViewConversionHelper { }; // RangeOp creates a new range descriptor. -class RangeOpConversion : public ConvertToLLVMPattern { +class RangeOpConversion : public ConvertOpToLLVMPattern<RangeOp> { public: - explicit RangeOpConversion(MLIRContext *context, LLVMTypeConverter &lowering_) - : ConvertToLLVMPattern(RangeOp::getOperationName(), context, lowering_) {} + using ConvertOpToLLVMPattern<RangeOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(RangeOp rangeOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto rangeOp = cast<RangeOp>(op); auto rangeDescriptorTy = convertRangeType( rangeOp.getType().cast<RangeType>(), *getTypeConverter()); - edsc::ScopedContext context(rewriter, op->getLoc()); + edsc::ScopedContext context(rewriter, rangeOp->getLoc()); // Fill in an aggregate value of the descriptor. RangeOpAdaptor adaptor(operands); @@ -146,7 +144,7 @@ class RangeOpConversion : public ConvertToLLVMPattern { desc = llvm_insertvalue(desc, adaptor.min(), rewriter.getI64ArrayAttr(0)); desc = llvm_insertvalue(desc, adaptor.max(), rewriter.getI64ArrayAttr(1)); desc = llvm_insertvalue(desc, adaptor.step(), rewriter.getI64ArrayAttr(2)); - rewriter.replaceOp(op, desc); + rewriter.replaceOp(rangeOp, desc); return success(); } }; @@ -154,17 +152,13 @@ class RangeOpConversion : public ConvertToLLVMPattern { // ReshapeOp creates a new view descriptor of the proper rank. // For now, the only conversion supported is for target MemRef with static sizes // and strides. -class ReshapeOpConversion : public ConvertToLLVMPattern { +class ReshapeOpConversion : public ConvertOpToLLVMPattern<ReshapeOp> { public: - explicit ReshapeOpConversion(MLIRContext *context, - LLVMTypeConverter &lowering_) - : ConvertToLLVMPattern(ReshapeOp::getOperationName(), context, - lowering_) {} + using ConvertOpToLLVMPattern<ReshapeOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(ReshapeOp reshapeOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto reshapeOp = cast<ReshapeOp>(op); MemRefType dstType = reshapeOp.getResultType(); if (!dstType.hasStaticShape()) @@ -178,7 +172,7 @@ class ReshapeOpConversion : public ConvertToLLVMPattern { })) return failure(); - edsc::ScopedContext context(rewriter, op->getLoc()); + edsc::ScopedContext context(rewriter, reshapeOp->getLoc()); ReshapeOpAdaptor adaptor(operands); BaseViewConversionHelper baseDesc(adaptor.src()); BaseViewConversionHelper desc(typeConverter->convertType(dstType)); @@ -189,7 +183,7 @@ class ReshapeOpConversion : public ConvertToLLVMPattern { desc.setConstantSize(en.index(), en.value()); for (auto en : llvm::enumerate(strides)) desc.setConstantStride(en.index(), en.value()); - rewriter.replaceOp(op, {desc}); + rewriter.replaceOp(reshapeOp, {desc}); return success(); } }; @@ -200,19 +194,17 @@ class ReshapeOpConversion : public ConvertToLLVMPattern { /// and stride corresponding to the region of memory within the bounds of /// the parent view. /// The linalg.slice op is replaced by the alloca'ed pointer. -class SliceOpConversion : public ConvertToLLVMPattern { +class SliceOpConversion : public ConvertOpToLLVMPattern<SliceOp> { public: - explicit SliceOpConversion(MLIRContext *context, LLVMTypeConverter &lowering_) - : ConvertToLLVMPattern(SliceOp::getOperationName(), context, lowering_) {} + using ConvertOpToLLVMPattern<SliceOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(SliceOp sliceOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - edsc::ScopedContext context(rewriter, op->getLoc()); + edsc::ScopedContext context(rewriter, sliceOp->getLoc()); SliceOpAdaptor adaptor(operands); BaseViewConversionHelper baseDesc(adaptor.view()); - auto sliceOp = cast<SliceOp>(op); auto memRefType = sliceOp.getBaseViewType(); auto int64Ty = typeConverter->convertType(rewriter.getIntegerType(64)) .cast<LLVM::LLVMType>(); @@ -248,7 +240,7 @@ class SliceOpConversion : public ConvertToLLVMPattern { // Corner case, no sizes or strides: early return the descriptor. if (sliceOp.getShapedType().getRank() == 0) - return rewriter.replaceOp(op, {desc}), success(); + return rewriter.replaceOp(sliceOp, {desc}), success(); Value zero = llvm_constant( int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0)); @@ -279,20 +271,18 @@ class SliceOpConversion : public ConvertToLLVMPattern { } } - rewriter.replaceOp(op, {desc}); + rewriter.replaceOp(sliceOp, {desc}); return success(); } }; // YieldOp produces and LLVM::ReturnOp. -class YieldOpConversion : public ConvertToLLVMPattern { +class YieldOpConversion : public ConvertOpToLLVMPattern<linalg::YieldOp> { public: - explicit YieldOpConversion(MLIRContext *context, LLVMTypeConverter &lowering_) - : ConvertToLLVMPattern(linalg::YieldOp::getOperationName(), context, - lowering_) {} + using ConvertOpToLLVMPattern<linalg::YieldOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(linalg::YieldOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { rewriter.replaceOpWithNewOp<LLVM::ReturnOp>(op, operands); return success(); @@ -302,10 +292,9 @@ class YieldOpConversion : public ConvertToLLVMPattern { /// Populate the given list with patterns that convert from Linalg to LLVM. void mlir::populateLinalgToLLVMConversionPatterns( - LLVMTypeConverter &converter, OwningRewritePatternList &patterns, - MLIRContext *ctx) { + LLVMTypeConverter &converter, OwningRewritePatternList &patterns) { patterns.insert<RangeOpConversion, ReshapeOpConversion, SliceOpConversion, - YieldOpConversion>(ctx, converter); + YieldOpConversion>(converter); // Populate the type conversions for the linalg types. converter.addConversion( @@ -331,7 +320,7 @@ void ConvertLinalgToLLVMPass::runOnOperation() { populateVectorToSCFConversionPatterns(patterns, &getContext()); populateVectorToLLVMMatrixConversionPatterns(converter, patterns); populateVectorToLLVMConversionPatterns(converter, patterns); - populateLinalgToLLVMConversionPatterns(converter, patterns, &getContext()); + populateLinalgToLLVMConversionPatterns(converter, patterns); LLVMConversionTarget target(getContext()); target.addLegalOp<ModuleOp, ModuleTerminatorOp>(); diff --git a/mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp b/mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp index c589ef69f2c4..e970d82c86df 100644 --- a/mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp +++ b/mlir/lib/Conversion/OpenMPToLLVM/OpenMPToLLVM.cpp @@ -21,34 +21,30 @@ namespace { /// expected to either be processed by the conversion infrastructure or already /// contain ops compatible with LLVM dialect types. template <typename OpType> -struct RegionOpConversion : public ConvertToLLVMPattern { - explicit RegionOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(OpType::getOperationName(), context, - typeConverter) {} +struct RegionOpConversion : public ConvertOpToLLVMPattern<OpType> { + using ConvertOpToLLVMPattern<OpType>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(OpType curOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto curOp = cast<OpType>(op); auto newOp = rewriter.create<OpType>(curOp.getLoc(), TypeRange(), operands, curOp.getAttrs()); rewriter.inlineRegionBefore(curOp.region(), newOp.region(), newOp.region().end()); - if (failed(rewriter.convertRegionTypes(&newOp.region(), *typeConverter))) + if (failed(rewriter.convertRegionTypes(&newOp.region(), + *this->getTypeConverter()))) return failure(); - rewriter.eraseOp(op); + rewriter.eraseOp(curOp); return success(); } }; } // namespace void mlir::populateOpenMPToLLVMConversionPatterns( - MLIRContext *context, LLVMTypeConverter &converter, - OwningRewritePatternList &patterns) { + LLVMTypeConverter &converter, OwningRewritePatternList &patterns) { patterns.insert<RegionOpConversion<omp::ParallelOp>, - RegionOpConversion<omp::WsLoopOp>>(context, converter); + RegionOpConversion<omp::WsLoopOp>>(converter); } namespace { @@ -60,13 +56,12 @@ struct ConvertOpenMPToLLVMPass void ConvertOpenMPToLLVMPass::runOnOperation() { auto module = getOperation(); - MLIRContext *context = &getContext(); // Convert to OpenMP operations with LLVM IR dialect OwningRewritePatternList patterns; LLVMTypeConverter converter(&getContext()); populateStdToLLVMConversionPatterns(converter, patterns); - populateOpenMPToLLVMConversionPatterns(context, converter, patterns); + populateOpenMPToLLVMConversionPatterns(converter, patterns); LLVMConversionTarget target(getContext()); target.addDynamicallyLegalOp<omp::ParallelOp, omp::WsLoopOp>( diff --git a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp index 85d3e2bddd66..ebe07366f6ec 100644 --- a/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp +++ b/mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp @@ -296,39 +296,33 @@ namespace { /// Conversion pattern for a vector.matrix_multiply. /// This is lowered directly to the proper llvm.intr.matrix.multiply. -class VectorMatmulOpConversion : public ConvertToLLVMPattern { +class VectorMatmulOpConversion + : public ConvertOpToLLVMPattern<vector::MatmulOp> { public: - explicit VectorMatmulOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::MatmulOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::MatmulOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::MatmulOp matmulOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto matmulOp = cast<vector::MatmulOp>(op); auto adaptor = vector::MatmulOpAdaptor(operands); rewriter.replaceOpWithNewOp<LLVM::MatrixMultiplyOp>( - op, typeConverter->convertType(matmulOp.res().getType()), adaptor.lhs(), - adaptor.rhs(), matmulOp.lhs_rows(), matmulOp.lhs_columns(), - matmulOp.rhs_columns()); + matmulOp, typeConverter->convertType(matmulOp.res().getType()), + adaptor.lhs(), adaptor.rhs(), matmulOp.lhs_rows(), + matmulOp.lhs_columns(), matmulOp.rhs_columns()); return success(); } }; /// Conversion pattern for a vector.flat_transpose. /// This is lowered directly to the proper llvm.intr.matrix.transpose. -class VectorFlatTransposeOpConversion : public ConvertToLLVMPattern { +class VectorFlatTransposeOpConversion + : public ConvertOpToLLVMPattern<vector::FlatTransposeOp> { public: - explicit VectorFlatTransposeOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::FlatTransposeOp::getOperationName(), - context, typeConverter) {} + using ConvertOpToLLVMPattern<vector::FlatTransposeOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::FlatTransposeOp transOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto transOp = cast<vector::FlatTransposeOp>(op); auto adaptor = vector::FlatTransposeOpAdaptor(operands); rewriter.replaceOpWithNewOp<LLVM::MatrixTransposeOp>( transOp, typeConverter->convertType(transOp.res().getType()), @@ -338,18 +332,15 @@ class VectorFlatTransposeOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.maskedload. -class VectorMaskedLoadOpConversion : public ConvertToLLVMPattern { +class VectorMaskedLoadOpConversion + : public ConvertOpToLLVMPattern<vector::MaskedLoadOp> { public: - explicit VectorMaskedLoadOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::MaskedLoadOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::MaskedLoadOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::MaskedLoadOp load, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto load = cast<vector::MaskedLoadOp>(op); + auto loc = load->getLoc(); auto adaptor = vector::MaskedLoadOpAdaptor(operands); // Resolve alignment. @@ -371,18 +362,15 @@ class VectorMaskedLoadOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.maskedstore. -class VectorMaskedStoreOpConversion : public ConvertToLLVMPattern { +class VectorMaskedStoreOpConversion + : public ConvertOpToLLVMPattern<vector::MaskedStoreOp> { public: - explicit VectorMaskedStoreOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::MaskedStoreOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::MaskedStoreOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::MaskedStoreOp store, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto store = cast<vector::MaskedStoreOp>(op); + auto loc = store->getLoc(); auto adaptor = vector::MaskedStoreOpAdaptor(operands); // Resolve alignment. @@ -404,18 +392,15 @@ class VectorMaskedStoreOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.gather. -class VectorGatherOpConversion : public ConvertToLLVMPattern { +class VectorGatherOpConversion + : public ConvertOpToLLVMPattern<vector::GatherOp> { public: - explicit VectorGatherOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::GatherOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::GatherOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::GatherOp gather, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto gather = cast<vector::GatherOp>(op); + auto loc = gather->getLoc(); auto adaptor = vector::GatherOpAdaptor(operands); // Resolve alignment. @@ -440,18 +425,15 @@ class VectorGatherOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.scatter. -class VectorScatterOpConversion : public ConvertToLLVMPattern { +class VectorScatterOpConversion + : public ConvertOpToLLVMPattern<vector::ScatterOp> { public: - explicit VectorScatterOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::ScatterOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::ScatterOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ScatterOp scatter, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto scatter = cast<vector::ScatterOp>(op); + auto loc = scatter->getLoc(); auto adaptor = vector::ScatterOpAdaptor(operands); // Resolve alignment. @@ -476,18 +458,15 @@ class VectorScatterOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.expandload. -class VectorExpandLoadOpConversion : public ConvertToLLVMPattern { +class VectorExpandLoadOpConversion + : public ConvertOpToLLVMPattern<vector::ExpandLoadOp> { public: - explicit VectorExpandLoadOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::ExpandLoadOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::ExpandLoadOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ExpandLoadOp expand, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto expand = cast<vector::ExpandLoadOp>(op); + auto loc = expand->getLoc(); auto adaptor = vector::ExpandLoadOpAdaptor(operands); Value ptr; @@ -497,25 +476,22 @@ class VectorExpandLoadOpConversion : public ConvertToLLVMPattern { auto vType = expand.getResultVectorType(); rewriter.replaceOpWithNewOp<LLVM::masked_expandload>( - op, typeConverter->convertType(vType), ptr, adaptor.mask(), + expand, typeConverter->convertType(vType), ptr, adaptor.mask(), adaptor.pass_thru()); return success(); } }; /// Conversion pattern for a vector.compressstore. -class VectorCompressStoreOpConversion : public ConvertToLLVMPattern { +class VectorCompressStoreOpConversion + : public ConvertOpToLLVMPattern<vector::CompressStoreOp> { public: - explicit VectorCompressStoreOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::CompressStoreOp::getOperationName(), - context, typeConverter) {} + using ConvertOpToLLVMPattern<vector::CompressStoreOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::CompressStoreOp compress, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - auto compress = cast<vector::CompressStoreOp>(op); + auto loc = compress->getLoc(); auto adaptor = vector::CompressStoreOpAdaptor(operands); Value ptr; @@ -524,25 +500,23 @@ class VectorCompressStoreOpConversion : public ConvertToLLVMPattern { return failure(); rewriter.replaceOpWithNewOp<LLVM::masked_compressstore>( - op, adaptor.value(), ptr, adaptor.mask()); + compress, adaptor.value(), ptr, adaptor.mask()); return success(); } }; /// Conversion pattern for all vector reductions. -class VectorReductionOpConversion : public ConvertToLLVMPattern { +class VectorReductionOpConversion + : public ConvertOpToLLVMPattern<vector::ReductionOp> { public: - explicit VectorReductionOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter, + explicit VectorReductionOpConversion(LLVMTypeConverter &typeConv, bool reassociateFPRed) - : ConvertToLLVMPattern(vector::ReductionOp::getOperationName(), context, - typeConverter), + : ConvertOpToLLVMPattern<vector::ReductionOp>(typeConv), reassociateFPReductions(reassociateFPRed) {} LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ReductionOp reductionOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto reductionOp = cast<vector::ReductionOp>(op); auto kind = reductionOp.kind(); Type eltType = reductionOp.dest().getType(); Type llvmType = typeConverter->convertType(eltType); @@ -550,33 +524,33 @@ class VectorReductionOpConversion : public ConvertToLLVMPattern { // Integer reductions: add/mul/min/max/and/or/xor. if (kind == "add") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_add>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "mul") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_mul>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "min" && (eltType.isIndex() || eltType.isUnsignedInteger())) rewriter.replaceOpWithNewOp<LLVM::vector_reduce_umin>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "min") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_smin>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "max" && (eltType.isIndex() || eltType.isUnsignedInteger())) rewriter.replaceOpWithNewOp<LLVM::vector_reduce_umax>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "max") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_smax>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "and") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_and>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "or") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_or>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else if (kind == "xor") rewriter.replaceOpWithNewOp<LLVM::vector_reduce_xor>( - op, llvmType, operands[0]); + reductionOp, llvmType, operands[0]); else return failure(); return success(); @@ -590,27 +564,27 @@ class VectorReductionOpConversion : public ConvertToLLVMPattern { // Optional accumulator (or zero). Value acc = operands.size() > 1 ? operands[1] : rewriter.create<LLVM::ConstantOp>( - op->getLoc(), llvmType, + reductionOp->getLoc(), llvmType, rewriter.getZeroAttr(eltType)); rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fadd>( - op, llvmType, acc, operands[0], + reductionOp, llvmType, acc, operands[0], rewriter.getBoolAttr(reassociateFPReductions)); } else if (kind == "mul") { // Optional accumulator (or one). Value acc = operands.size() > 1 ? operands[1] : rewriter.create<LLVM::ConstantOp>( - op->getLoc(), llvmType, + reductionOp->getLoc(), llvmType, rewriter.getFloatAttr(eltType, 1.0)); rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fmul>( - op, llvmType, acc, operands[0], + reductionOp, llvmType, acc, operands[0], rewriter.getBoolAttr(reassociateFPReductions)); } else if (kind == "min") - rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fmin>(op, llvmType, - operands[0]); + rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fmin>( + reductionOp, llvmType, operands[0]); else if (kind == "max") - rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fmax>(op, llvmType, - operands[0]); + rewriter.replaceOpWithNewOp<LLVM::vector_reduce_fmax>( + reductionOp, llvmType, operands[0]); else return failure(); return success(); @@ -621,17 +595,16 @@ class VectorReductionOpConversion : public ConvertToLLVMPattern { }; /// Conversion pattern for a vector.create_mask (1-D only). -class VectorCreateMaskOpConversion : public ConvertToLLVMPattern { +class VectorCreateMaskOpConversion + : public ConvertOpToLLVMPattern<vector::CreateMaskOp> { public: - explicit VectorCreateMaskOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter, + explicit VectorCreateMaskOpConversion(LLVMTypeConverter &typeConv, bool enableIndexOpt) - : ConvertToLLVMPattern(vector::CreateMaskOp::getOperationName(), context, - typeConverter), + : ConvertOpToLLVMPattern<vector::CreateMaskOp>(typeConv), enableIndexOptimizations(enableIndexOpt) {} LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::CreateMaskOp op, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { auto dstType = op->getResult(0).getType().cast<VectorType>(); int64_t rank = dstType.getRank(); @@ -648,19 +621,16 @@ class VectorCreateMaskOpConversion : public ConvertToLLVMPattern { const bool enableIndexOptimizations; }; -class VectorShuffleOpConversion : public ConvertToLLVMPattern { +class VectorShuffleOpConversion + : public ConvertOpToLLVMPattern<vector::ShuffleOp> { public: - explicit VectorShuffleOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::ShuffleOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::ShuffleOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ShuffleOp shuffleOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); + auto loc = shuffleOp->getLoc(); auto adaptor = vector::ShuffleOpAdaptor(operands); - auto shuffleOp = cast<vector::ShuffleOp>(op); auto v1Type = shuffleOp.getV1VectorType(); auto v2Type = shuffleOp.getV2VectorType(); auto vectorType = shuffleOp.getVectorType(); @@ -680,9 +650,9 @@ class VectorShuffleOpConversion : public ConvertToLLVMPattern { // For rank 1, where both operands have *exactly* the same vector type, // there is direct shuffle support in LLVM. Use it! if (rank == 1 && v1Type == v2Type) { - Value shuffle = rewriter.create<LLVM::ShuffleVectorOp>( + Value llvmShuffleOp = rewriter.create<LLVM::ShuffleVectorOp>( loc, adaptor.v1(), adaptor.v2(), maskArrayAttr); - rewriter.replaceOp(op, shuffle); + rewriter.replaceOp(shuffleOp, llvmShuffleOp); return success(); } @@ -701,23 +671,22 @@ class VectorShuffleOpConversion : public ConvertToLLVMPattern { insert = insertOne(rewriter, *getTypeConverter(), loc, insert, extract, llvmType, rank, insPos++); } - rewriter.replaceOp(op, insert); + rewriter.replaceOp(shuffleOp, insert); return success(); } }; -class VectorExtractElementOpConversion : public ConvertToLLVMPattern { +class VectorExtractElementOpConversion + : public ConvertOpToLLVMPattern<vector::ExtractElementOp> { public: - explicit VectorExtractElementOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::ExtractElementOp::getOperationName(), - context, typeConverter) {} + using ConvertOpToLLVMPattern< + vector::ExtractElementOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ExtractElementOp extractEltOp, + ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { auto adaptor = vector::ExtractElementOpAdaptor(operands); - auto extractEltOp = cast<vector::ExtractElementOp>(op); auto vectorType = extractEltOp.getVectorType(); auto llvmType = typeConverter->convertType(vectorType.getElementType()); @@ -726,24 +695,21 @@ class VectorExtractElementOpConversion : public ConvertToLLVMPattern { return failure(); rewriter.replaceOpWithNewOp<LLVM::ExtractElementOp>( - op, llvmType, adaptor.vector(), adaptor.position()); + extractEltOp, llvmType, adaptor.vector(), adaptor.position()); return success(); } }; -class VectorExtractOpConversion : public ConvertToLLVMPattern { +class VectorExtractOpConversion + : public ConvertOpToLLVMPattern<vector::ExtractOp> { public: - explicit VectorExtractOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::ExtractOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::ExtractOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::ExtractOp extractOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); + auto loc = extractOp->getLoc(); auto adaptor = vector::ExtractOpAdaptor(operands); - auto extractOp = cast<vector::ExtractOp>(op); auto vectorType = extractOp.getVectorType(); auto resultType = extractOp.getResult().getType(); auto llvmResultType = typeConverter->convertType(resultType); @@ -757,12 +723,12 @@ class VectorExtractOpConversion : public ConvertToLLVMPattern { if (resultType.isa<VectorType>()) { Value extracted = rewriter.create<LLVM::ExtractValueOp>( loc, llvmResultType, adaptor.vector(), positionArrayAttr); - rewriter.replaceOp(op, extracted); + rewriter.replaceOp(extractOp, extracted); return success(); } // Potential extraction of 1-D vector from array. - auto *context = op->getContext(); + auto *context = extractOp->getContext(); Value extracted = adaptor.vector(); auto positionAttrs = positionArrayAttr.getValue(); if (positionAttrs.size() > 1) { @@ -780,7 +746,7 @@ class VectorExtractOpConversion : public ConvertToLLVMPattern { auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position); extracted = rewriter.create<LLVM::ExtractElementOp>(loc, extracted, constant); - rewriter.replaceOp(op, extracted); + rewriter.replaceOp(extractOp, extracted); return success(); } @@ -800,39 +766,32 @@ class VectorExtractOpConversion : public ConvertToLLVMPattern { /// (!llvm<"<8 x float>">, !llvm<"<8 x float>">, !llvm<"<8 x float>">) /// -> !llvm<"<8 x float>"> /// ``` -class VectorFMAOp1DConversion : public ConvertToLLVMPattern { +class VectorFMAOp1DConversion : public ConvertOpToLLVMPattern<vector::FMAOp> { public: - explicit VectorFMAOp1DConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::FMAOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::FMAOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::FMAOp fmaOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { auto adaptor = vector::FMAOpAdaptor(operands); - vector::FMAOp fmaOp = cast<vector::FMAOp>(op); VectorType vType = fmaOp.getVectorType(); if (vType.getRank() != 1) return failure(); - rewriter.replaceOpWithNewOp<LLVM::FMulAddOp>(op, adaptor.lhs(), + rewriter.replaceOpWithNewOp<LLVM::FMulAddOp>(fmaOp, adaptor.lhs(), adaptor.rhs(), adaptor.acc()); return success(); } }; -class VectorInsertElementOpConversion : public ConvertToLLVMPattern { +class VectorInsertElementOpConversion + : public ConvertOpToLLVMPattern<vector::InsertElementOp> { public: - explicit VectorInsertElementOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::InsertElementOp::getOperationName(), - context, typeConverter) {} + using ConvertOpToLLVMPattern<vector::InsertElementOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::InsertElementOp insertEltOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { auto adaptor = vector::InsertElementOpAdaptor(operands); - auto insertEltOp = cast<vector::InsertElementOp>(op); auto vectorType = insertEltOp.getDestVectorType(); auto llvmType = typeConverter->convertType(vectorType); @@ -841,24 +800,22 @@ class VectorInsertElementOpConversion : public ConvertToLLVMPattern { return failure(); rewriter.replaceOpWithNewOp<LLVM::InsertElementOp>( - op, llvmType, adaptor.dest(), adaptor.source(), adaptor.position()); + insertEltOp, llvmType, adaptor.dest(), adaptor.source(), + adaptor.position()); return success(); } }; -class VectorInsertOpConversion : public ConvertToLLVMPattern { +class VectorInsertOpConversion + : public ConvertOpToLLVMPattern<vector::InsertOp> { public: - explicit VectorInsertOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::InsertOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::InsertOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::InsertOp insertOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); + auto loc = insertOp->getLoc(); auto adaptor = vector::InsertOpAdaptor(operands); - auto insertOp = cast<vector::InsertOp>(op); auto sourceType = insertOp.getSourceType(); auto destVectorType = insertOp.getDestVectorType(); auto llvmResultType = typeConverter->convertType(destVectorType); @@ -873,12 +830,12 @@ class VectorInsertOpConversion : public ConvertToLLVMPattern { Value inserted = rewriter.create<LLVM::InsertValueOp>( loc, llvmResultType, adaptor.dest(), adaptor.source(), positionArrayAttr); - rewriter.replaceOp(op, inserted); + rewriter.replaceOp(insertOp, inserted); return success(); } // Potential extraction of 1-D vector from array. - auto *context = op->getContext(); + auto *context = insertOp->getContext(); Value extracted = adaptor.dest(); auto positionAttrs = positionArrayAttr.getValue(); auto position = positionAttrs.back().cast<IntegerAttr>(); @@ -908,7 +865,7 @@ class VectorInsertOpConversion : public ConvertToLLVMPattern { nMinusOnePositionAttrs); } - rewriter.replaceOp(op, inserted); + rewriter.replaceOp(insertOp, inserted); return success(); } }; @@ -1117,18 +1074,15 @@ computeContiguousStrides(MemRefType memRefType) { return strides; } -class VectorTypeCastOpConversion : public ConvertToLLVMPattern { +class VectorTypeCastOpConversion + : public ConvertOpToLLVMPattern<vector::TypeCastOp> { public: - explicit VectorTypeCastOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::TypeCastOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::TypeCastOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::TypeCastOp castOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto loc = op->getLoc(); - vector::TypeCastOp castOp = cast<vector::TypeCastOp>(op); + auto loc = castOp->getLoc(); MemRefType sourceMemRefType = castOp.getOperand().getType().cast<MemRefType>(); MemRefType targetMemRefType = @@ -1195,7 +1149,7 @@ class VectorTypeCastOpConversion : public ConvertToLLVMPattern { desc.setStride(rewriter, loc, index, stride); } - rewriter.replaceOp(op, {desc}); + rewriter.replaceOp(castOp, {desc}); return success(); } }; @@ -1208,18 +1162,16 @@ class VectorTypeCastOpConversion : public ConvertToLLVMPattern { /// 4. Create a mask where offsetVector is compared against memref upper bound. /// 5. Rewrite op as a masked read or write. template <typename ConcreteOp> -class VectorTransferConversion : public ConvertToLLVMPattern { +class VectorTransferConversion : public ConvertOpToLLVMPattern<ConcreteOp> { public: - explicit VectorTransferConversion(MLIRContext *context, - LLVMTypeConverter &typeConv, + explicit VectorTransferConversion(LLVMTypeConverter &typeConv, bool enableIndexOpt) - : ConvertToLLVMPattern(ConcreteOp::getOperationName(), context, typeConv), + : ConvertOpToLLVMPattern<ConcreteOp>(typeConv), enableIndexOptimizations(enableIndexOpt) {} LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(ConcreteOp xferOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto xferOp = cast<ConcreteOp>(op); auto adaptor = getTransferOpAdapter(xferOp, operands); if (xferOp.getVectorType().getRank() > 1 || @@ -1228,16 +1180,18 @@ class VectorTransferConversion : public ConvertToLLVMPattern { if (xferOp.permutation_map() != AffineMap::getMinorIdentityMap(xferOp.permutation_map().getNumInputs(), xferOp.getVectorType().getRank(), - op->getContext())) + xferOp->getContext())) return failure(); // Only contiguous source tensors supported atm. auto strides = computeContiguousStrides(xferOp.getMemRefType()); if (!strides) return failure(); - auto toLLVMTy = [&](Type t) { return typeConverter->convertType(t); }; + auto toLLVMTy = [&](Type t) { + return this->getTypeConverter()->convertType(t); + }; - Location loc = op->getLoc(); + Location loc = xferOp->getLoc(); MemRefType memRefType = xferOp.getMemRefType(); if (auto memrefVectorElementType = @@ -1267,8 +1221,8 @@ class VectorTransferConversion : public ConvertToLLVMPattern { // addrspacecast shall be used when source/dst memrefs are not on // address space 0. // TODO: support alignment when possible. - Value dataPtr = getStridedElementPtr(loc, memRefType, adaptor.memref(), - adaptor.indices(), rewriter); + Value dataPtr = this->getStridedElementPtr( + loc, memRefType, adaptor.memref(), adaptor.indices(), rewriter); auto vecTy = toLLVMTy(xferOp.getVectorType()).template cast<LLVM::LLVMType>(); Value vectorDataPtr; @@ -1280,8 +1234,9 @@ class VectorTransferConversion : public ConvertToLLVMPattern { loc, vecTy.getPointerTo(), dataPtr); if (!xferOp.isMaskedDim(0)) - return replaceTransferOpWithLoadOrStore( - rewriter, *getTypeConverter(), loc, xferOp, operands, vectorDataPtr); + return replaceTransferOpWithLoadOrStore(rewriter, + *this->getTypeConverter(), loc, + xferOp, operands, vectorDataPtr); // 2. Create a vector with linear indices [ 0 .. vector_length - 1 ]. // 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ]. @@ -1294,11 +1249,11 @@ class VectorTransferConversion : public ConvertToLLVMPattern { unsigned lastIndex = llvm::size(xferOp.indices()) - 1; Value off = xferOp.indices()[lastIndex]; Value dim = rewriter.create<DimOp>(loc, xferOp.memref(), lastIndex); - Value mask = buildVectorComparison(rewriter, op, enableIndexOptimizations, - vecWidth, dim, &off); + Value mask = buildVectorComparison( + rewriter, xferOp, enableIndexOptimizations, vecWidth, dim, &off); // 5. Rewrite as a masked read / write. - return replaceTransferOpWithMasked(rewriter, *getTypeConverter(), loc, + return replaceTransferOpWithMasked(rewriter, *this->getTypeConverter(), loc, xferOp, operands, vectorDataPtr, mask); } @@ -1306,12 +1261,9 @@ class VectorTransferConversion : public ConvertToLLVMPattern { const bool enableIndexOptimizations; }; -class VectorPrintOpConversion : public ConvertToLLVMPattern { +class VectorPrintOpConversion : public ConvertOpToLLVMPattern<vector::PrintOp> { public: - explicit VectorPrintOpConversion(MLIRContext *context, - LLVMTypeConverter &typeConverter) - : ConvertToLLVMPattern(vector::PrintOp::getOperationName(), context, - typeConverter) {} + using ConvertOpToLLVMPattern<vector::PrintOp>::ConvertOpToLLVMPattern; // Proof-of-concept lowering implementation that relies on a small // runtime support library, which only needs to provide a few @@ -1326,9 +1278,8 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern { // TODO: rely solely on libc in future? something else? // LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(vector::PrintOp printOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto printOp = cast<vector::PrintOp>(op); auto adaptor = vector::PrintOpAdaptor(operands); Type printType = printOp.getPrintType(); @@ -1341,11 +1292,11 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern { Type eltType = vectorType ? vectorType.getElementType() : printType; Operation *printer; if (eltType.isF32()) { - printer = getPrintFloat(op); + printer = getPrintFloat(printOp); } else if (eltType.isF64()) { - printer = getPrintDouble(op); + printer = getPrintDouble(printOp); } else if (eltType.isIndex()) { - printer = getPrintU64(op); + printer = getPrintU64(printOp); } else if (auto intTy = eltType.dyn_cast<IntegerType>()) { // Integers need a zero or sign extension on the operand // (depending on the source type) as well as a signed or @@ -1355,7 +1306,7 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern { if (width <= 64) { if (width < 64) conversion = PrintConversion::ZeroExt64; - printer = getPrintU64(op); + printer = getPrintU64(printOp); } else { return failure(); } @@ -1368,7 +1319,7 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern { conversion = PrintConversion::ZeroExt64; else if (width < 64) conversion = PrintConversion::SignExt64; - printer = getPrintI64(op); + printer = getPrintI64(printOp); } else { return failure(); } @@ -1379,10 +1330,10 @@ class VectorPrintOpConversion : public ConvertToLLVMPattern { // Unroll vector into elementary print calls. int64_t rank = vectorType ? vectorType.getRank() : 0; - emitRanks(rewriter, op, adaptor.source(), vectorType, printer, rank, + emitRanks(rewriter, printOp, adaptor.source(), vectorType, printer, rank, conversion); - emitCall(rewriter, op->getLoc(), getPrintNewline(op)); - rewriter.eraseOp(op); + emitCall(rewriter, printOp->getLoc(), getPrintNewline(printOp)); + rewriter.eraseOp(printOp); return success(); } @@ -1560,11 +1511,11 @@ void mlir::populateVectorToLLVMConversionPatterns( VectorInsertStridedSliceOpSameRankRewritePattern, VectorExtractStridedSliceOpConversion>(ctx); patterns.insert<VectorReductionOpConversion>( - ctx, converter, reassociateFPReductions); + converter, reassociateFPReductions); patterns.insert<VectorCreateMaskOpConversion, VectorTransferConversion<TransferReadOp>, VectorTransferConversion<TransferWriteOp>>( - ctx, converter, enableIndexOptimizations); + converter, enableIndexOptimizations); patterns .insert<VectorShuffleOpConversion, VectorExtractElementOpConversion, @@ -1579,13 +1530,12 @@ void mlir::populateVectorToLLVMConversionPatterns( VectorGatherOpConversion, VectorScatterOpConversion, VectorExpandLoadOpConversion, - VectorCompressStoreOpConversion>(ctx, converter); + VectorCompressStoreOpConversion>(converter); // clang-format on } void mlir::populateVectorToLLVMMatrixConversionPatterns( LLVMTypeConverter &converter, OwningRewritePatternList &patterns) { - MLIRContext *ctx = converter.getDialect()->getContext(); - patterns.insert<VectorMatmulOpConversion>(ctx, converter); - patterns.insert<VectorFlatTransposeOpConversion>(ctx, converter); + patterns.insert<VectorMatmulOpConversion>(converter); + patterns.insert<VectorFlatTransposeOpConversion>(converter); } diff --git a/mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp b/mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp index 61f094746a0a..e5474abfd3e3 100644 --- a/mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp +++ b/mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp @@ -55,17 +55,13 @@ namespace { /// types. For unsupported cases, they will fall back to the vector to /// llvm conversion pattern. template <typename ConcreteOp> -class VectorTransferConversion : public ConvertToLLVMPattern { +class VectorTransferConversion : public ConvertOpToLLVMPattern<ConcreteOp> { public: - explicit VectorTransferConversion(MLIRContext *context, - LLVMTypeConverter &typeConv) - : ConvertToLLVMPattern(ConcreteOp::getOperationName(), context, - typeConv) {} + using ConvertOpToLLVMPattern<ConcreteOp>::ConvertOpToLLVMPattern; LogicalResult - matchAndRewrite(Operation *op, ArrayRef<Value> operands, + matchAndRewrite(ConcreteOp xferOp, ArrayRef<Value> operands, ConversionPatternRewriter &rewriter) const override { - auto xferOp = cast<ConcreteOp>(op); typename ConcreteOp::Adaptor adaptor(operands); if (xferOp.getVectorType().getRank() > 1 || @@ -79,11 +75,13 @@ class VectorTransferConversion : public ConvertToLLVMPattern { if (!xferOp.isMaskedDim(0)) return failure(); - auto toLLVMTy = [&](Type t) { return typeConverter->convertType(t); }; + auto toLLVMTy = [&](Type t) { + return this->getTypeConverter()->convertType(t); + }; LLVM::LLVMType vecTy = toLLVMTy(xferOp.getVectorType()).template cast<LLVM::LLVMType>(); unsigned vecWidth = vecTy.getVectorNumElements(); - Location loc = op->getLoc(); + Location loc = xferOp->getLoc(); // The backend result vector scalarization have trouble scalarize // <1 x ty> result, exclude the x1 width from the lowering. @@ -102,8 +100,8 @@ class VectorTransferConversion : public ConvertToLLVMPattern { // Note that the dataPtr starts at the offset address specified by // indices, so no need to calculate offset size in bytes again in // the MUBUF instruction. - Value dataPtr = getStridedElementPtr(loc, memRefType, adaptor.memref(), - adaptor.indices(), rewriter); + Value dataPtr = this->getStridedElementPtr( + loc, memRefType, adaptor.memref(), adaptor.indices(), rewriter); // 1. Create and fill a <4 x i32> dwordConfig with: // 1st two elements holding the address of dataPtr. @@ -126,7 +124,7 @@ class VectorTransferConversion : public ConvertToLLVMPattern { constConfig); Value dataPtrAsI64 = rewriter.create<LLVM::PtrToIntOp>( loc, toLLVMTy(i64Ty).template cast<LLVM::LLVMType>(), dataPtr); - Value zero = createIndexConstant(rewriter, loc, 0); + Value zero = this->createIndexConstant(rewriter, loc, 0); Value dwordConfig = rewriter.create<LLVM::InsertElementOp>( loc, LLVM::LLVMType::getVectorTy( @@ -143,7 +141,7 @@ class VectorTransferConversion : public ConvertToLLVMPattern { loc, toLLVMTy(i32Ty), rewriter.getIntegerAttr(rewriter.getIntegerType(32), 0)); return replaceTransferOpWithMubuf( - rewriter, operands, *getTypeConverter(), loc, xferOp, vecTy, + rewriter, operands, *this->getTypeConverter(), loc, xferOp, vecTy, dwordConfig, int32Zero, int32Zero, int1False, int1False); } }; @@ -151,9 +149,8 @@ class VectorTransferConversion : public ConvertToLLVMPattern { void mlir::populateVectorToROCDLConversionPatterns( LLVMTypeConverter &converter, OwningRewritePatternList &patterns) { - MLIRContext *ctx = converter.getDialect()->getContext(); patterns.insert<VectorTransferConversion<TransferReadOp>, - VectorTransferConversion<TransferWriteOp>>(ctx, converter); + VectorTransferConversion<TransferWriteOp>>(converter); } namespace { _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits