[mlir][spirv] NFC: Merge ArithToSPIRV pattern decl and definition

[antiagainst]

Summary

This makes the code easier to search and read.

[jpienaar]

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

150

OOC why not use the standalone function form (https://github.com/llvm/llvm-project/commit/6874726610cc2f9eea7fa828c8585bf84969f9c3) here given no benefits specified?

[kuhar]

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

150

Cool, TIL!
Seems like this should be able to cover the vast majority of patterns but I haven't seen it used in MLIR/IREE, do you know the reasons for it?

[antiagainst]

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

150

Ha, interesting! Didn't notice that! However it does not support conversion patterns though?

[antiagainst]

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

150

I'll land this for now. We can further clean/tidy things later.

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

 #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::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::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::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::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::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::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::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::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::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::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::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::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::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::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_extended to spirv.IAddCarry.
-class AddUIExtendedOpPattern final
-    : public OpConversionPattern<arith::AddUIExtendedOp> {
-public:
-  using OpConversionPattern::OpConversionPattern;
-  LogicalResult
-  matchAndRewrite(arith::AddUIExtendedOp op, OpAdaptor adaptor,
-                  ConversionPatternRewriter &rewriter) const override;
-};
-
-/// Converts arith.mul*i_extended to spirv.*MulExtended.
-template <typename ArithMulOp, typename SPIRVMulOp>
-class MulIExtendedOpPattern final : public OpConversionPattern<ArithMulOp> {
-public:
-  using OpConversionPattern<ArithMulOp>::OpConversionPattern;
-  LogicalResult
-  matchAndRewrite(ArithMulOp op, typename ArithMulOp::Adaptor adaptor,
-                  ConversionPatternRewriter &rewriter) const override;
-};
-
-/// Converts arith.select to spirv.Select.
-class SelectOpPattern final : public OpConversionPattern<arith::SelectOp> {
-public:
-  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> {
-public:
-  using OpConversionPattern<Op>::OpConversionPattern;
-  LogicalResult
-  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
-                  ConversionPatternRewriter &rewriter) const override;
-};
-
-} // namespace
-
-//===----------------------------------------------------------------------===//
 // Conversion Helpers
 //===----------------------------------------------------------------------===//
 
 /// 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 = dyn_cast<BoolAttr>(srcAttr))
     return boolAttr;

 
 /// Returns a source type conversion failure for the result type of `op`.
 static LogicalResult
 getTypeConversionFailure(ConversionPatternRewriter &rewriter, Operation *op) {
   assert(op->getNumResults() == 1);
   return getTypeConversionFailure(rewriter, op, op->getResultTypes().front());
 }
 
+namespace {
+
 //===----------------------------------------------------------------------===//
-// ConstantOp with composite type
+// ConstantOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
-    arith::ConstantOp constOp, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+/// Converts composite arith.constant operation to spirv.Constant.
+struct ConstantCompositeOpPattern final
+    : public OpConversionPattern<arith::ConstantOp> {
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(arith::ConstantOp constOp, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     auto srcType = dyn_cast<ShapedType>(constOp.getType());
     if (!srcType || srcType.getNumElements() == 1)
       return failure();
 
     // arith.constant should only have vector or tenor types.
     assert((isa<VectorType, RankedTensorType>(srcType)));
 
     Type dstType = getTypeConverter()->convertType(srcType);
     if (!dstType)
       return failure();
 
     auto dstElementsAttr = dyn_cast<DenseElementsAttr>(constOp.getValue());
     if (!dstElementsAttr)
       return failure();
 
     ShapedType dstAttrType = dstElementsAttr.getType();
 
-  // If the composite type has more than one dimensions, perform linearization.
+    // If the composite type has more than one dimensions, perform
+    // linearization.
     if (srcType.getRank() > 1) {
       if (isa<RankedTensorType>(srcType)) {
         dstAttrType = RankedTensorType::get(srcType.getNumElements(),
                                             srcType.getElementType());
         dstElementsAttr = dstElementsAttr.reshape(dstAttrType);
       } else {
         // TODO: add support for large vectors.
         return failure();
       }
     }
 
     Type srcElemType = srcType.getElementType();
     Type dstElemType;
     // Tensor types are converted to SPIR-V array types; vector types are
     // converted to SPIR-V vector/array types.
     if (auto arrayType = dyn_cast<spirv::ArrayType>(dstType))
       dstElemType = arrayType.getElementType();
     else
       dstElemType = cast<VectorType>(dstType).getElementType();
 
     // If the source and destination element types are different, perform
     // attribute conversion.
     if (srcElemType != dstElemType) {
       SmallVector<Attribute, 8> elements;
       if (isa<FloatType>(srcElemType)) {
         for (FloatAttr srcAttr : dstElementsAttr.getValues<FloatAttr>()) {
           FloatAttr dstAttr =
               convertFloatAttr(srcAttr, cast<FloatType>(dstElemType), rewriter);
           if (!dstAttr)
             return failure();
           elements.push_back(dstAttr);
         }
       } else if (srcElemType.isInteger(1)) {
         return failure();
       } else {
         for (IntegerAttr srcAttr : dstElementsAttr.getValues<IntegerAttr>()) {
           IntegerAttr dstAttr = convertIntegerAttr(
               srcAttr, cast<IntegerType>(dstElemType), rewriter);
           if (!dstAttr)
             return failure();
           elements.push_back(dstAttr);
         }
       }
 
       // Unfortunately, we cannot use dialect-specific types for element
-    // attributes; element attributes only works with builtin types. So we need
-    // to prepare another converted builtin types for the destination elements
-    // attribute.
+      // attributes; element attributes only works with builtin types. So we
+      // need to prepare another converted builtin types for the destination
+      // elements attribute.
       if (isa<RankedTensorType>(dstAttrType))
-      dstAttrType = RankedTensorType::get(dstAttrType.getShape(), dstElemType);
+        dstAttrType =
+            RankedTensorType::get(dstAttrType.getShape(), dstElemType);
       else
         dstAttrType = VectorType::get(dstAttrType.getShape(), dstElemType);
 
       dstElementsAttr = DenseElementsAttr::get(dstAttrType, elements);
     }
 
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType,
                                                    dstElementsAttr);
     return success();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// ConstantOp with scalar type
-//===----------------------------------------------------------------------===//
+/// Converts scalar arith.constant operation to spirv.Constant.
+struct ConstantScalarOpPattern final
+    : public OpConversionPattern<arith::ConstantOp> {
+  using OpConversionPattern::OpConversionPattern;
 
-LogicalResult ConstantScalarOpPattern::matchAndRewrite(
-    arith::ConstantOp constOp, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+  LogicalResult
+  matchAndRewrite(arith::ConstantOp constOp, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type srcType = constOp.getType();
     if (auto shapedType = dyn_cast<ShapedType>(srcType)) {
       if (shapedType.getNumElements() != 1)
         return failure();
       srcType = shapedType.getElementType();
     }
     if (!srcType.isIntOrIndexOrFloat())
       return failure();
 
     Attribute cstAttr = constOp.getValue();
     if (auto elementsAttr = dyn_cast<DenseElementsAttr>(cstAttr))
       cstAttr = elementsAttr.getSplatValue<Attribute>();
 
     Type dstType = getTypeConverter()->convertType(srcType);
     if (!dstType)
       return failure();
 
     // Floating-point types.
     if (isa<FloatType>(srcType)) {
       auto srcAttr = cast<FloatAttr>(cstAttr);
       auto dstAttr = srcAttr;
 
       // Floating-point types not supported in the target environment are all
       // converted to float type.
       if (srcType != dstType) {
         dstAttr = convertFloatAttr(srcAttr, cast<FloatType>(dstType), rewriter);
         if (!dstAttr)
           return failure();
       }
 
       rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
       return success();
     }
 
     // Bool type.
     if (srcType.isInteger(1)) {
       // arith.constant can use 0/1 instead of true/false for i1 values. We need
       // to handle that here.
       auto dstAttr = convertBoolAttr(cstAttr, rewriter);
       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 = cast<IntegerAttr>(cstAttr);
     IntegerAttr dstAttr =
         convertIntegerAttr(srcAttr, cast<IntegerType>(dstType), rewriter);
     if (!dstAttr)
       return failure();
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// RemSIOpGLPattern
+// RemSIOp
 //===----------------------------------------------------------------------===//
 
 /// Returns signed remainder for `lhs` and `rhs` and lets the result follow
 /// the sign of `signOperand`.
 ///
 /// Note that this is needed for Vulkan. Per the Vulkan's SPIR-V environment
 /// spec, "for the OpSRem and OpSMod instructions, if either operand is negative
 /// the result is undefined."  So we cannot directly use spirv.SRem/spirv.SMod
static Value emulateSignedRemainder(Location loc, Value lhs, Value rhs,
   if (lhs == signOperand)
     isPositive = builder.create<spirv::IEqualOp>(loc, lhs, lhsAbs);
   else
     isPositive = builder.create<spirv::IEqualOp>(loc, rhs, rhsAbs);
   Value absNegate = builder.create<spirv::SNegateOp>(loc, type, abs);
   return builder.create<spirv::SelectOp>(loc, type, isPositive, abs, absNegate);
 }
 
+/// 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::OpConversionPattern;
+
   LogicalResult
-RemSIOpGLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
-                                  ConversionPatternRewriter &rewriter) const {
-  Value result = emulateSignedRemainder<spirv::GLSAbsOp>(
+  matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    Value result = emulateSignedRemainder<spirv::CLSAbsOp>(
         op.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
         adaptor.getOperands()[0], rewriter);
     rewriter.replaceOp(op, result);
 
     return success();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// RemSIOpCLPattern
-//===----------------------------------------------------------------------===//
+/// Converts arith.remsi to OpenCL SPIR-V ops.
+struct RemSIOpCLPattern final : public OpConversionPattern<arith::RemSIOp> {
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-RemSIOpCLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
-                                  ConversionPatternRewriter &rewriter) const {
-  Value result = emulateSignedRemainder<spirv::CLSAbsOp>(
+  matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
+    Value result = emulateSignedRemainder<spirv::GLSAbsOp>(
         op.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
         adaptor.getOperands()[0], rewriter);
     rewriter.replaceOp(op, result);
 
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// BitwiseOpPattern
+// BitwiseOp
 //===----------------------------------------------------------------------===//
 
+/// 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
-BitwiseOpPattern<Op, SPIRVLogicalOp, SPIRVBitwiseOp>::matchAndRewrite(
-    Op op, typename Op::Adaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     assert(adaptor.getOperands().size() == 2);
     Type dstType = this->getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     if (isBoolScalarOrVector(adaptor.getOperands().front().getType())) {
-    rewriter.template replaceOpWithNewOp<SPIRVLogicalOp>(op, dstType,
-                                                         adaptor.getOperands());
+      rewriter.template replaceOpWithNewOp<SPIRVLogicalOp>(
+          op, dstType, adaptor.getOperands());
     } else {
-    rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(op, dstType,
-                                                         adaptor.getOperands());
+      rewriter.template replaceOpWithNewOp<SPIRVBitwiseOp>(
+          op, dstType, adaptor.getOperands());
     }
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// XOrIOpLogicalPattern
+// XOrIOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult XOrIOpLogicalPattern::matchAndRewrite(
-    arith::XOrIOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+/// Converts arith.xori to SPIR-V operations.
+struct XOrIOpLogicalPattern final : public OpConversionPattern<arith::XOrIOp> {
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(arith::XOrIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     assert(adaptor.getOperands().size() == 2);
 
     if (isBoolScalarOrVector(adaptor.getOperands().front().getType()))
       return failure();
 
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     rewriter.replaceOpWithNewOp<spirv::BitwiseXorOp>(op, dstType,
                                                      adaptor.getOperands());
 
     return success();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// XOrIOpBooleanPattern
-//===----------------------------------------------------------------------===//
+/// 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::OpConversionPattern;
 
-LogicalResult XOrIOpBooleanPattern::matchAndRewrite(
-    arith::XOrIOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+  LogicalResult
+  matchAndRewrite(arith::XOrIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     assert(adaptor.getOperands().size() == 2);
 
     if (!isBoolScalarOrVector(adaptor.getOperands().front().getType()))
       return failure();
 
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
-  rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(op, dstType,
-                                                        adaptor.getOperands());
+    rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(
+        op, dstType, adaptor.getOperands());
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// UIToFPI1Pattern
+// UIToFPOp
 //===----------------------------------------------------------------------===//
 
+/// 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::OpConversionPattern;
+
   LogicalResult
-UIToFPI1Pattern::matchAndRewrite(arith::UIToFPOp op, OpAdaptor adaptor,
-                                 ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::UIToFPOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type srcType = adaptor.getOperands().front().getType();
     if (!isBoolScalarOrVector(srcType))
       return failure();
 
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     Location loc = op.getLoc();
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(
         op, dstType, adaptor.getOperands().front(), one, zero);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// ExtSII1Pattern
+// ExtSIOp
 //===----------------------------------------------------------------------===//
 
+/// 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::OpConversionPattern;
+
   LogicalResult
-ExtSII1Pattern::matchAndRewrite(arith::ExtSIOp op, OpAdaptor adaptor,
-                                ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::ExtSIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Value operand = adaptor.getIn();
     if (!isBoolScalarOrVector(operand.getType()))
       return failure();
 
     Location loc = op.getLoc();
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     Value allOnes;
     if (auto intTy = dyn_cast<IntegerType>(dstType)) {
       unsigned componentBitwidth = intTy.getWidth();
       allOnes = rewriter.create<spirv::ConstantOp>(
           loc, intTy,
           rewriter.getIntegerAttr(intTy, APInt::getAllOnes(componentBitwidth)));
     } else if (auto vectorTy = dyn_cast<VectorType>(dstType)) {
       unsigned componentBitwidth = vectorTy.getElementTypeBitWidth();
       allOnes = rewriter.create<spirv::ConstantOp>(
           loc, vectorTy,
-        SplatElementsAttr::get(vectorTy, APInt::getAllOnes(componentBitwidth)));
+          SplatElementsAttr::get(vectorTy,
+                                 APInt::getAllOnes(componentBitwidth)));
     } else {
       return rewriter.notifyMatchFailure(
           loc, llvm::formatv("unhandled type: {0}", dstType));
     }
 
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, dstType, operand, allOnes,
                                                  zero);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// ExtUII1Pattern
+// ExtUIOp
 //===----------------------------------------------------------------------===//
 
+/// 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::OpConversionPattern;
+
   LogicalResult
-ExtUII1Pattern::matchAndRewrite(arith::ExtUIOp op, OpAdaptor adaptor,
-                                ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::ExtUIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type srcType = adaptor.getOperands().front().getType();
     if (!isBoolScalarOrVector(srcType))
       return failure();
 
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     Location loc = op.getLoc();
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(
         op, dstType, adaptor.getOperands().front(), one, zero);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// TruncII1Pattern
+// TruncIOp
 //===----------------------------------------------------------------------===//
 
+/// 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::OpConversionPattern;
+
   LogicalResult
-TruncII1Pattern::matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
-                                 ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::TruncIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type dstType = getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     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>(
         loc, srcType, adaptor.getOperands()[0], mask);
     Value isOne = rewriter.create<spirv::IEqualOp>(loc, maskedSrc, mask);
 
     Value zero = spirv::ConstantOp::getZero(dstType, loc, rewriter);
     Value one = spirv::ConstantOp::getOne(dstType, loc, rewriter);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, dstType, isOne, one, zero);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// TypeCastingOpPattern
+// TypeCastingOp
 //===----------------------------------------------------------------------===//
 
+/// Converts type-casting standard operations to SPIR-V operations.
 template <typename Op, typename SPIRVOp>
-LogicalResult TypeCastingOpPattern<Op, SPIRVOp>::matchAndRewrite(
-    Op op, typename Op::Adaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+struct TypeCastingOpPattern final : public OpConversionPattern<Op> {
+  using OpConversionPattern<Op>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     assert(adaptor.getOperands().size() == 1);
     Type srcType = adaptor.getOperands().front().getType();
     Type dstType = this->getTypeConverter()->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     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 {
       rewriter.template replaceOpWithNewOp<SPIRVOp>(op, dstType,
                                                     adaptor.getOperands());
     }
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// CmpIOpBooleanPattern
+// CmpIOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult CmpIOpBooleanPattern::matchAndRewrite(
-    arith::CmpIOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+/// Converts integer compare operation on i1 type operands to SPIR-V ops.
+class CmpIOpBooleanPattern final : public OpConversionPattern<arith::CmpIOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type srcType = op.getLhs().getType();
     if (!isBoolScalarOrVector(srcType))
       return failure();
     Type dstType = getTypeConverter()->convertType(srcType);
     if (!dstType)
       return getTypeConversionFailure(rewriter, op, srcType);
 
     switch (op.getPredicate()) {
     case arith::CmpIPredicate::eq: {
       rewriter.replaceOpWithNewOp<spirv::LogicalEqualOp>(op, adaptor.getLhs(),
                                                          adaptor.getRhs());
       return success();
     }
     case arith::CmpIPredicate::ne: {
-    rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(op, adaptor.getLhs(),
-                                                          adaptor.getRhs());
+      rewriter.replaceOpWithNewOp<spirv::LogicalNotEqualOp>(
+          op, adaptor.getLhs(), adaptor.getRhs());
       return success();
     }
     case arith::CmpIPredicate::uge:
     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.
+      // 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 = dyn_cast<VectorType>(dstType))
         type = VectorType::get(vectorType.getShape(), type);
       Value extLhs =
           rewriter.create<arith::ExtUIOp>(op.getLoc(), type, adaptor.getLhs());
       Value extRhs =
           rewriter.create<arith::ExtUIOp>(op.getLoc(), type, adaptor.getRhs());
 
       rewriter.replaceOpWithNewOp<arith::CmpIOp>(op, op.getPredicate(), extLhs,
                                                  extRhs);
       return success();
     }
     default:
       break;
     }
     return failure();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// CmpIOpPattern
-//===----------------------------------------------------------------------===//
+/// Converts integer compare operation to SPIR-V ops.
+class CmpIOpPattern final : public OpConversionPattern<arith::CmpIOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
-CmpIOpPattern::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
-                               ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type srcType = op.getLhs().getType();
     if (isBoolScalarOrVector(srcType))
       return failure();
     Type dstType = getTypeConverter()->convertType(srcType);
     if (!dstType)
       return getTypeConversionFailure(rewriter, op, srcType);
 
     switch (op.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     if (spirvOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&            \
         !getElementTypeOrSelf(srcType).isIndex() && srcType != dstType &&      \
         !hasSameBitwidth(srcType, dstType)) {                                  \
       return op.emitError(                                                     \
           "bitwidth emulation is not implemented yet on unsigned op");         \
     }                                                                          \
     rewriter.replaceOpWithNewOp<spirvOp>(op, adaptor.getLhs(),                 \
                                          adaptor.getRhs());                    \
     return success();
 
       DISPATCH(arith::CmpIPredicate::eq, spirv::IEqualOp);
       DISPATCH(arith::CmpIPredicate::ne, spirv::INotEqualOp);
       DISPATCH(arith::CmpIPredicate::slt, spirv::SLessThanOp);
       DISPATCH(arith::CmpIPredicate::sle, spirv::SLessThanEqualOp);
       DISPATCH(arith::CmpIPredicate::sgt, spirv::SGreaterThanOp);
       DISPATCH(arith::CmpIPredicate::sge, spirv::SGreaterThanEqualOp);
       DISPATCH(arith::CmpIPredicate::ult, spirv::ULessThanOp);
       DISPATCH(arith::CmpIPredicate::ule, spirv::ULessThanEqualOp);
       DISPATCH(arith::CmpIPredicate::ugt, spirv::UGreaterThanOp);
       DISPATCH(arith::CmpIPredicate::uge, spirv::UGreaterThanEqualOp);
 
 #undef DISPATCH
     }
     return failure();
   }
+};
 
 //===----------------------------------------------------------------------===//
 // CmpFOpPattern
 //===----------------------------------------------------------------------===//
 
+/// Converts floating-point comparison operations to SPIR-V ops.
+class CmpFOpPattern final : public OpConversionPattern<arith::CmpFOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
+
   LogicalResult
-CmpFOpPattern::matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
-                               ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     switch (op.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     rewriter.replaceOpWithNewOp<spirvOp>(op, adaptor.getLhs(),                 \
                                          adaptor.getRhs());                    \
     return success();
 
       // Ordered.
       DISPATCH(arith::CmpFPredicate::OEQ, spirv::FOrdEqualOp);
       DISPATCH(arith::CmpFPredicate::OGT, spirv::FOrdGreaterThanOp);
       DISPATCH(arith::CmpFPredicate::OGE, spirv::FOrdGreaterThanEqualOp);
       DISPATCH(arith::CmpFPredicate::OLT, spirv::FOrdLessThanOp);
       DISPATCH(arith::CmpFPredicate::OLE, spirv::FOrdLessThanEqualOp);
       DISPATCH(arith::CmpFPredicate::ONE, spirv::FOrdNotEqualOp);
       // Unordered.
       DISPATCH(arith::CmpFPredicate::UEQ, spirv::FUnordEqualOp);
       DISPATCH(arith::CmpFPredicate::UGT, spirv::FUnordGreaterThanOp);
       DISPATCH(arith::CmpFPredicate::UGE, spirv::FUnordGreaterThanEqualOp);
       DISPATCH(arith::CmpFPredicate::ULT, spirv::FUnordLessThanOp);
       DISPATCH(arith::CmpFPredicate::ULE, spirv::FUnordLessThanEqualOp);
       DISPATCH(arith::CmpFPredicate::UNE, spirv::FUnordNotEqualOp);
 
 #undef DISPATCH
 
     default:
       break;
     }
     return failure();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// CmpFOpNanKernelPattern
-//===----------------------------------------------------------------------===//
+/// Converts floating point NaN check to SPIR-V ops. This pattern requires
+/// Kernel capability.
+class CmpFOpNanKernelPattern final : public OpConversionPattern<arith::CmpFOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
 
-LogicalResult CmpFOpNanKernelPattern::matchAndRewrite(
-    arith::CmpFOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+  LogicalResult
+  matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     if (op.getPredicate() == arith::CmpFPredicate::ORD) {
       rewriter.replaceOpWithNewOp<spirv::OrderedOp>(op, adaptor.getLhs(),
                                                     adaptor.getRhs());
       return success();
     }
 
     if (op.getPredicate() == arith::CmpFPredicate::UNO) {
       rewriter.replaceOpWithNewOp<spirv::UnorderedOp>(op, adaptor.getLhs(),
                                                       adaptor.getRhs());
       return success();
     }
 
     return failure();
   }
+};
 
-//===----------------------------------------------------------------------===//
-// CmpFOpNanNonePattern
-//===----------------------------------------------------------------------===//
+/// 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 CmpFOpNanNonePattern::matchAndRewrite(
-    arith::CmpFOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+  LogicalResult
+  matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     if (op.getPredicate() != arith::CmpFPredicate::ORD &&
         op.getPredicate() != arith::CmpFPredicate::UNO)
       return failure();
 
     Location loc = op.getLoc();
     auto *converter = getTypeConverter<SPIRVTypeConverter>();
 
     Value replace;
     if (converter->getOptions().enableFastMathMode) {
       if (op.getPredicate() == arith::CmpFPredicate::ORD) {
         // Ordered comparsion checks if neither operand is NaN.
         replace = spirv::ConstantOp::getOne(op.getType(), loc, rewriter);
       } else {
         // Unordered comparsion checks if either operand is NaN.
         replace = spirv::ConstantOp::getZero(op.getType(), loc, rewriter);
       }
     } else {
       Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getLhs());
       Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getRhs());
 
       replace = rewriter.create<spirv::LogicalOrOp>(loc, lhsIsNan, rhsIsNan);
       if (op.getPredicate() == arith::CmpFPredicate::ORD)
         replace = rewriter.create<spirv::LogicalNotOp>(loc, replace);
     }
 
     rewriter.replaceOp(op, replace);
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// AddUIExtendedOpPattern
+// AddUIExtendedOp
 //===----------------------------------------------------------------------===//
 
-LogicalResult AddUIExtendedOpPattern::matchAndRewrite(
-    arith::AddUIExtendedOp op, OpAdaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+/// Converts arith.addui_extended to spirv.IAddCarry.
+class AddUIExtendedOpPattern final
+    : public OpConversionPattern<arith::AddUIExtendedOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
+  LogicalResult
+  matchAndRewrite(arith::AddUIExtendedOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Type dstElemTy = adaptor.getLhs().getType();
     Location loc = op->getLoc();
     Value result = rewriter.create<spirv::IAddCarryOp>(loc, adaptor.getLhs(),
                                                        adaptor.getRhs());
 
     Value sumResult = rewriter.create<spirv::CompositeExtractOp>(
         loc, result, llvm::ArrayRef(0));
     Value carryValue = rewriter.create<spirv::CompositeExtractOp>(
         loc, result, llvm::ArrayRef(1));
 
     // Convert the carry value to boolean.
     Value one = spirv::ConstantOp::getOne(dstElemTy, loc, rewriter);
     Value carryResult = rewriter.create<spirv::IEqualOp>(loc, carryValue, one);
 
     rewriter.replaceOp(op, {sumResult, carryResult});
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// MulIExtendedOpPattern
+// MulIExtendedOp
 //===----------------------------------------------------------------------===//
 
+/// Converts arith.mul*i_extended to spirv.*MulExtended.
 template <typename ArithMulOp, typename SPIRVMulOp>
-LogicalResult MulIExtendedOpPattern<ArithMulOp, SPIRVMulOp>::matchAndRewrite(
-    ArithMulOp op, typename ArithMulOp::Adaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+class MulIExtendedOpPattern final : public OpConversionPattern<ArithMulOp> {
+public:
+  using OpConversionPattern<ArithMulOp>::OpConversionPattern;
+  LogicalResult
+  matchAndRewrite(ArithMulOp op, typename ArithMulOp::Adaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     Location loc = op->getLoc();
     Value result =
         rewriter.create<SPIRVMulOp>(loc, adaptor.getLhs(), adaptor.getRhs());
 
     Value low = rewriter.create<spirv::CompositeExtractOp>(loc, result,
                                                            llvm::ArrayRef(0));
     Value high = rewriter.create<spirv::CompositeExtractOp>(loc, result,
                                                             llvm::ArrayRef(1));
 
     rewriter.replaceOp(op, {low, high});
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// SelectOpPattern
+// SelectOp
 //===----------------------------------------------------------------------===//
 
+/// Converts arith.select to spirv.Select.
+class SelectOpPattern final : public OpConversionPattern<arith::SelectOp> {
+public:
+  using OpConversionPattern::OpConversionPattern;
   LogicalResult
-SelectOpPattern::matchAndRewrite(arith::SelectOp op, OpAdaptor adaptor,
-                                 ConversionPatternRewriter &rewriter) const {
+  matchAndRewrite(arith::SelectOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, adaptor.getCondition(),
                                                  adaptor.getTrueValue(),
                                                  adaptor.getFalseValue());
     return success();
   }
+};
 
 //===----------------------------------------------------------------------===//
-// MaxFOpPattern
+// MaxFOp
 //===----------------------------------------------------------------------===//
 
+/// Converts arith.maxf to spirv.GL.FMax or spirv.CL.fmax.
 template <typename Op, typename SPIRVOp>
-LogicalResult MinMaxFOpPattern<Op, SPIRVOp>::matchAndRewrite(
-    Op op, typename Op::Adaptor adaptor,
-    ConversionPatternRewriter &rewriter) const {
+class MinMaxFOpPattern final : public OpConversionPattern<Op> {
+public:
+  using OpConversionPattern<Op>::OpConversionPattern;
+  LogicalResult
+  matchAndRewrite(Op op, typename Op::Adaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const override {
     auto *converter = this->template getTypeConverter<SPIRVTypeConverter>();
     Type dstType = converter->convertType(op.getType());
     if (!dstType)
       return getTypeConversionFailure(rewriter, op);
 
     // 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."
     // spirv.CL.fmax/fmin:
     //   "If one argument is a NaN, Fmin returns the other argument."
 
     Location loc = op.getLoc();
-  Value spirvOp = rewriter.create<SPIRVOp>(loc, dstType, adaptor.getOperands());
+    Value spirvOp =
+        rewriter.create<SPIRVOp>(loc, dstType, adaptor.getOperands());
 
     if (converter->getOptions().enableFastMathMode) {
       rewriter.replaceOp(op, spirvOp);
       return success();
     }
 
     Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getLhs());
     Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getRhs());
 
     Value select1 = rewriter.create<spirv::SelectOp>(loc, dstType, lhsIsNan,
                                                      adaptor.getLhs(), spirvOp);
     Value select2 = rewriter.create<spirv::SelectOp>(loc, dstType, rhsIsNan,
                                                      adaptor.getRhs(), select1);
 
     rewriter.replaceOp(op, select2);
     return success();
   }
+};
+
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern Population
 //===----------------------------------------------------------------------===//
 
 void mlir::arith::populateArithToSPIRVPatterns(
     SPIRVTypeConverter &typeConverter, RewritePatternSet &patterns) {
   // clang-format off