[mlir][arith][spirv] Clean up arith-to-spirv. NFC.

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

 //===- ArithToSPIRV.cpp - Arithmetic to SPIRV dialect conversion -----===//
 //
 // 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/Conversion/ArithToSPIRV/ArithToSPIRV.h"
 
 #include "../SPIRVCommon/Pattern.h"
-#include "mlir/Conversion/FuncToSPIRV/FuncToSPIRV.h"
 #include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Debug.h"
 #include <cassert>
+#include <memory>
 
 namespace mlir {
 #define GEN_PASS_DEF_CONVERTARITHTOSPIRV
 #include "mlir/Conversion/Passes.h.inc"
 } // namespace mlir
 
 #define DEBUG_TYPE "arith-to-spirv-pattern"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Operation Conversion
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Converts composite arith.constant operation to spirv.Constant.
 struct ConstantCompositeOpPattern final
     : public OpConversionPattern<arith::ConstantOp> {
-  using OpConversionPattern<arith::ConstantOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts scalar arith.constant operation to spirv.Constant.
 struct ConstantScalarOpPattern final
     : public OpConversionPattern<arith::ConstantOp> {
-  using OpConversionPattern<arith::ConstantOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.remsi to GLSL SPIR-V ops.
 ///
 /// This cannot be merged into the template unary/binary pattern due to Vulkan
 /// restrictions over spirv.SRem and spirv.SMod.
 struct RemSIOpGLPattern final : public OpConversionPattern<arith::RemSIOp> {
-  using OpConversionPattern<arith::RemSIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.remsi to OpenCL SPIR-V ops.
 struct RemSIOpCLPattern final : public OpConversionPattern<arith::RemSIOp> {
-  using OpConversionPattern<arith::RemSIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts bitwise operations to SPIR-V operations. This is a special pattern
 /// other than the BinaryOpPatternPattern because if the operands are boolean
 /// values, SPIR-V uses different operations (`SPIRVLogicalOp`). For
 /// non-boolean operands, SPIR-V should use `SPIRVBitwiseOp`.
 template <typename Op, typename SPIRVLogicalOp, typename SPIRVBitwiseOp>
 struct BitwiseOpPattern final : public OpConversionPattern<Op> {
   using OpConversionPattern<Op>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(Op op, typename Op::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.xori to SPIR-V operations.
 struct XOrIOpLogicalPattern final : public OpConversionPattern<arith::XOrIOp> {
-  using OpConversionPattern<arith::XOrIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::XOrIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.xori to SPIR-V operations if the type of source is i1 or
 /// vector of i1.
 struct XOrIOpBooleanPattern final : public OpConversionPattern<arith::XOrIOp> {
-  using OpConversionPattern<arith::XOrIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::XOrIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.uitofp to spirv.Select if the type of source is i1 or vector
 /// of i1.
 struct UIToFPI1Pattern final : public OpConversionPattern<arith::UIToFPOp> {
-  using OpConversionPattern<arith::UIToFPOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::UIToFPOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.extsi to spirv.Select if the type of source is i1 or vector
 /// of i1.
 struct ExtSII1Pattern final : public OpConversionPattern<arith::ExtSIOp> {
-  using OpConversionPattern<arith::ExtSIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::ExtSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.extui to spirv.Select if the type of source is i1 or vector
 /// of i1.
 struct ExtUII1Pattern final : public OpConversionPattern<arith::ExtUIOp> {
-  using OpConversionPattern<arith::ExtUIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::ExtUIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.trunci to spirv.Select if the type of result is i1 or vector
 /// of i1.
 struct TruncII1Pattern final : public OpConversionPattern<arith::TruncIOp> {
-  using OpConversionPattern<arith::TruncIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts type-casting standard operations to SPIR-V operations.
 template <typename Op, typename SPIRVOp>
 struct TypeCastingOpPattern final : public OpConversionPattern<Op> {
   using OpConversionPattern<Op>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(Op op, typename Op::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts integer compare operation on i1 type operands to SPIR-V ops.
 class CmpIOpBooleanPattern final : public OpConversionPattern<arith::CmpIOp> {
 public:
-  using OpConversionPattern<arith::CmpIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts integer compare operation to SPIR-V ops.
 class CmpIOpPattern final : public OpConversionPattern<arith::CmpIOp> {
 public:
-  using OpConversionPattern<arith::CmpIOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating-point comparison operations to SPIR-V ops.
 class CmpFOpPattern final : public OpConversionPattern<arith::CmpFOp> {
 public:
-  using OpConversionPattern<arith::CmpFOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating point NaN check to SPIR-V ops. This pattern requires
 /// Kernel capability.
 class CmpFOpNanKernelPattern final : public OpConversionPattern<arith::CmpFOp> {
 public:
-  using OpConversionPattern<arith::CmpFOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts floating point NaN check to SPIR-V ops. This pattern does not
 /// require additional capability.
 class CmpFOpNanNonePattern final : public OpConversionPattern<arith::CmpFOp> {
 public:
   using OpConversionPattern<arith::CmpFOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.addui_carry to spirv.IAddCarry.
 class AddICarryOpPattern final
     : public OpConversionPattern<arith::AddUICarryOp> {
 public:
-  using OpConversionPattern<arith::AddUICarryOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(arith::AddUICarryOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.select to spirv.Select.
 class SelectOpPattern final : public OpConversionPattern<arith::SelectOp> {
 public:
-  using OpConversionPattern<arith::SelectOp>::OpConversionPattern;
+  using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(arith::SelectOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.maxf to spirv.GL.FMax or spirv.CL.fmax.
 template <typename Op, typename SPIRVOp>
 class MinMaxFOpPattern final : public OpConversionPattern<Op> {

 
 /// Converts the given `srcAttr` into a boolean attribute if it holds an
 /// integral value. Returns null attribute if conversion fails.
 static BoolAttr convertBoolAttr(Attribute srcAttr, Builder builder) {
   if (auto boolAttr = srcAttr.dyn_cast<BoolAttr>())
     return boolAttr;
   if (auto intAttr = srcAttr.dyn_cast<IntegerAttr>())
     return builder.getBoolAttr(intAttr.getValue().getBoolValue());
-  return BoolAttr();
+  return {};
 }
 
 /// Converts the given `srcAttr` to a new attribute of the given `dstType`.
 /// Returns null attribute if conversion fails.
 static IntegerAttr convertIntegerAttr(IntegerAttr srcAttr, IntegerType dstType,
                                       Builder builder) {
   // If the source number uses less active bits than the target bitwidth, then
   // it should be safe to convert.
if (srcAttr.getValue().isSignedIntN(dstType.getWidth())) {
     LLVM_DEBUG(llvm::dbgs() << "attribute '" << srcAttr << "' converted to '"
                             << dstAttr << "' for type '" << dstType << "'\n");
     return dstAttr;
   }
 
   LLVM_DEBUG(llvm::dbgs() << "attribute '" << srcAttr
                           << "' illegal: cannot fit into target type '"
                           << dstType << "'\n");
-  return IntegerAttr();
+  return {};
 }
 
 /// Converts the given `srcAttr` to a new attribute of the given `dstType`.
 /// Returns null attribute if `dstType` is not 32-bit or conversion fails.
 static FloatAttr convertFloatAttr(FloatAttr srcAttr, FloatType dstType,
                                   Builder builder) {
   // Only support converting to float for now.
   if (!dstType.isF32())
LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
     ConversionPatternRewriter &rewriter) const {
   auto srcType = constOp.getType().dyn_cast<ShapedType>();
   if (!srcType || srcType.getNumElements() == 1)
     return failure();
 
   // arith.constant should only have vector or tenor types.
   assert((srcType.isa<VectorType, RankedTensorType>()));
 
-  auto dstType = getTypeConverter()->convertType(srcType);
+  Type dstType = getTypeConverter()->convertType(srcType);
   if (!dstType)
     return failure();
 
   auto dstElementsAttr = constOp.getValue().dyn_cast<DenseElementsAttr>();
   if (!dstElementsAttr)
     return failure();
 
   ShapedType dstAttrType = dstElementsAttr.getType();
if (!dstAttr)
       return failure();
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }
 
   // IndexType or IntegerType. Index values are converted to 32-bit integer
   // values when converting to SPIR-V.
   auto srcAttr = cstAttr.cast<IntegerAttr>();
-  auto dstAttr =
+  IntegerAttr dstAttr =
       convertIntegerAttr(srcAttr, dstType.cast<IntegerType>(), rewriter);
   if (!dstAttr)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
   return success();
 }
 
 //===----------------------------------------------------------------------===//

 LogicalResult XOrIOpLogicalPattern::matchAndRewrite(
     arith::XOrIOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   assert(adaptor.getOperands().size() == 2);
 
   if (isBoolScalarOrVector(adaptor.getOperands().front().getType()))
     return failure();
 
-  auto dstType = getTypeConverter()->convertType(op.getType());
+  Type dstType = getTypeConverter()->convertType(op.getType());
   if (!dstType)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::BitwiseXorOp>(op, dstType,
                                                    adaptor.getOperands());
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // XOrIOpBooleanPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult XOrIOpBooleanPattern::matchAndRewrite(
     arith::XOrIOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   assert(adaptor.getOperands().size() == 2);
 
   if (!isBoolScalarOrVector(adaptor.getOperands().front().getType()))
     return failure();
 
-  auto dstType = getTypeConverter()->convertType(op.getType());
+  Type dstType = getTypeConverter()->convertType(op.getType());
   if (!dstType)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(op, dstType,
                                                         adaptor.getOperands());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // UIToFPI1Pattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 UIToFPI1Pattern::matchAndRewrite(arith::UIToFPOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
-  auto srcType = adaptor.getOperands().front().getType();
+  Type srcType = adaptor.getOperands().front().getType();
   if (!isBoolScalarOrVector(srcType))
     return failure();
 
-  auto dstType =
-      this->getTypeConverter()->convertType(op.getResult().getType());
+  Type dstType = getTypeConverter()->convertType(op.getResult().getType());
   Location loc = op.getLoc();
   Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
   Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
-  rewriter.template replaceOpWithNewOp<spirv::SelectOp>(
+  rewriter.replaceOpWithNewOp<spirv::SelectOp>(
       op, dstType, adaptor.getOperands().front(), one, zero);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ExtSII1Pattern
 //===----------------------------------------------------------------------===//
 

 
 //===----------------------------------------------------------------------===//
 // ExtUII1Pattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 ExtUII1Pattern::matchAndRewrite(arith::ExtUIOp op, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  auto srcType = adaptor.getOperands().front().getType();
+  Type srcType = adaptor.getOperands().front().getType();
   if (!isBoolScalarOrVector(srcType))
     return failure();
 
-  auto dstType =
-      this->getTypeConverter()->convertType(op.getResult().getType());
+  Type dstType = getTypeConverter()->convertType(op.getResult().getType());
   Location loc = op.getLoc();
   Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
   Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
-  rewriter.template replaceOpWithNewOp<spirv::SelectOp>(
+  rewriter.replaceOpWithNewOp<spirv::SelectOp>(
       op, dstType, adaptor.getOperands().front(), one, zero);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // TruncII1Pattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 TruncII1Pattern::matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
-  auto dstType =
-      this->getTypeConverter()->convertType(op.getResult().getType());
+  Type dstType = getTypeConverter()->convertType(op.getResult().getType());
   if (!isBoolScalarOrVector(dstType))
     return failure();
 
   Location loc = op.getLoc();
   auto srcType = adaptor.getOperands().front().getType();
   // Check if (x & 1) == 1.
   Value mask = spirv::ConstantOp::getOne(srcType, loc, rewriter);
   Value maskedSrc = rewriter.create<spirv::BitwiseAndOp>(

 // TypeCastingOpPattern
 //===----------------------------------------------------------------------===//
 
 template <typename Op, typename SPIRVOp>
 LogicalResult TypeCastingOpPattern<Op, SPIRVOp>::matchAndRewrite(
     Op op, typename Op::Adaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   assert(adaptor.getOperands().size() == 1);
-  auto srcType = adaptor.getOperands().front().getType();
-  auto dstType =
+  Type srcType = adaptor.getOperands().front().getType();
+  Type dstType =
       this->getTypeConverter()->convertType(op.getResult().getType());
   if (isBoolScalarOrVector(srcType) || isBoolScalarOrVector(dstType))
     return failure();
   if (dstType == srcType) {
     // Due to type conversion, we are seeing the same source and target type.
     // Then we can just erase this operation by forwarding its operand.
     rewriter.replaceOp(op, adaptor.getOperands().front());
   } else {
LogicalResult CmpIOpBooleanPattern::matchAndRewrite(
   case arith::CmpIPredicate::ugt:
   case arith::CmpIPredicate::ule:
   case arith::CmpIPredicate::ult: {
     // There are no direct corresponding instructions in SPIR-V for such cases.
     // Extend them to 32-bit and do comparision then.
     Type type = rewriter.getI32Type();
     if (auto vectorType = dstType.dyn_cast<VectorType>())
       type = VectorType::get(vectorType.getShape(), type);
-    auto extLhs =
+    Value extLhs =
         rewriter.create<arith::ExtUIOp>(op.getLoc(), type, adaptor.getLhs());
-    auto extRhs =
+    Value extRhs =
         rewriter.create<arith::ExtUIOp>(op.getLoc(), type, adaptor.getRhs());
 
     rewriter.replaceOpWithNewOp<arith::CmpIOp>(op, op.getPredicate(), extLhs,
                                                extRhs);
     return success();
   }
   default:
     break;

 // MaxFOpPattern
 //===----------------------------------------------------------------------===//
 
 template <typename Op, typename SPIRVOp>
 LogicalResult MinMaxFOpPattern<Op, SPIRVOp>::matchAndRewrite(
     Op op, typename Op::Adaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto *converter = this->template getTypeConverter<SPIRVTypeConverter>();
-  auto dstType = converter->convertType(op.getType());
+  Type dstType = converter->convertType(op.getType());
   if (!dstType)
     return failure();
 
   // arith.maxf/minf:
   //   "if one of the arguments is NaN, then the result is also NaN."
   // spirv.GL.FMax/FMin
   //   "which operand is the result is undefined if one of the operands
   //   is a NaN."

 // Pass Definition
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct ConvertArithToSPIRVPass
     : public impl::ConvertArithToSPIRVBase<ConvertArithToSPIRVPass> {
   void runOnOperation() override {
     Operation *op = getOperation();
-    auto targetAttr = spirv::lookupTargetEnvOrDefault(op);
-    auto target = SPIRVConversionTarget::get(targetAttr);
+    spirv::TargetEnvAttr targetAttr = spirv::lookupTargetEnvOrDefault(op);
+    std::unique_ptr<SPIRVConversionTarget> target =
+        SPIRVConversionTarget::get(targetAttr);
 
     SPIRVConversionOptions options;
     options.emulateLT32BitScalarTypes = this->emulateLT32BitScalarTypes;
     options.enableFastMathMode = this->enableFastMath;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 
     // Use UnrealizedConversionCast as the bridge so that we don't need to pull
     // in patterns for other dialects.