[mlir] NFC: split Math to SPIR-V conversion into their own files

[antiagainst]

Summary

Depends On D107092

[hanchung]

Nice cleanup!

mlir/include/mlir/Conversion/MathToSPIRV/MathToSPIRV.h

+//===- MathToSPIRV.h - Math to SPIR-V Patterns ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides patterns to convert Math dialect to SPIR-V dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRV_H
+#define MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRV_H
+
+#include "mlir/Transforms/DialectConversion.h"
+
+namespace mlir {
+class SPIRVTypeConverter;
+
+/// Appends to a pattern list additional patterns for translating Math ops
+/// to SPIR-V ops.
+void populateMathToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
+                                 RewritePatternSet &patterns);
+
+} // namespace mlir
+
+#endif // MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRV_H

mlir/include/mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h

+//===- MathToSPIRVPass.h - Math to SPIR-V Passes ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides passes to convert Math dialect to SPIR-V dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H
+#define MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+
+/// Creates a pass to convert Math ops to SPIR-V ops.
+std::unique_ptr<OperationPass<ModuleOp>> createConvertMathToSPIRVPass();
+
+} // namespace mlir
+
+#endif // MLIR_CONVERSION_MATHTOSPIRV_MATHTOSPIRVPASS_H

mlir/include/mlir/Conversion/Passes.h

 #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
 #include "mlir/Conversion/GPUToSPIRV/GPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
 #include "mlir/Conversion/LinalgToStandard/LinalgToStandard.h"
 #include "mlir/Conversion/MathToLLVM/MathToLLVM.h"
 #include "mlir/Conversion/MathToLibm/MathToLibm.h"
+#include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
 #include "mlir/Conversion/MemRefToLLVM/MemRefToLLVM.h"
 #include "mlir/Conversion/OpenACCToLLVM/ConvertOpenACCToLLVM.h"
 #include "mlir/Conversion/OpenACCToSCF/ConvertOpenACCToSCF.h"
 #include "mlir/Conversion/OpenMPToLLVM/ConvertOpenMPToLLVM.h"
 #include "mlir/Conversion/PDLToPDLInterp/PDLToPDLInterp.h"
 #include "mlir/Conversion/SCFToGPU/SCFToGPUPass.h"
 #include "mlir/Conversion/SCFToOpenMP/SCFToOpenMP.h"
 #include "mlir/Conversion/SCFToSPIRV/SCFToSPIRVPass.h"

mlir/include/mlir/Conversion/Passes.td

def ConvertMathToLLVM : FunctionPass<"convert-math-to-llvm"> {
   let description = [{
     This pass converts supported Math ops to LLVM dialect intrinsics.
   }];
   let constructor = "mlir::createConvertMathToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
+// MathToSPIRV
+//===----------------------------------------------------------------------===//
+
+def ConvertMathToSPIRV : Pass<"convert-math-to-spirv", "ModuleOp"> {
+  let summary = "Convert Math dialect to SPIR-V dialect";
+  let constructor = "mlir::createConvertMathToSPIRVPass()";
+  let dependentDialects = ["spirv::SPIRVDialect"];
+}
+
+//===----------------------------------------------------------------------===//
 // MemRefToLLVM
 //===----------------------------------------------------------------------===//
 
 def ConvertMemRefToLLVM : Pass<"convert-memref-to-llvm", "ModuleOp"> {
   let summary = "Convert operations from the MemRef dialect to the LLVM "
                 "dialect";
   let constructor = "mlir::createMemRefToLLVMPass()";
   let dependentDialects = ["LLVM::LLVMDialect"];

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(AffineToStandard)
 add_subdirectory(ArmNeon2dToIntr)
 add_subdirectory(AsyncToLLVM)
 add_subdirectory(ComplexToLLVM)
 add_subdirectory(ComplexToStandard)
 add_subdirectory(GPUCommon)
 add_subdirectory(GPUToNVVM)
 add_subdirectory(GPUToROCDL)
 add_subdirectory(GPUToSPIRV)
 add_subdirectory(GPUToVulkan)
 add_subdirectory(LinalgToLLVM)
 add_subdirectory(LinalgToSPIRV)
 add_subdirectory(LinalgToStandard)
 add_subdirectory(LLVMCommon)
 add_subdirectory(MathToLibm)
 add_subdirectory(MathToLLVM)
+add_subdirectory(MathToSPIRV)
 add_subdirectory(MemRefToLLVM)
 add_subdirectory(OpenACCToLLVM)
 add_subdirectory(OpenACCToSCF)
 add_subdirectory(OpenMPToLLVM)
 add_subdirectory(PDLToPDLInterp)
 add_subdirectory(SCFToGPU)
 add_subdirectory(SCFToOpenMP)
 add_subdirectory(SCFToSPIRV)

mlir/lib/Conversion/MathToSPIRV/CMakeLists.txt

+add_mlir_conversion_library(MLIRMathToSPIRV
+  MathToSPIRV.cpp
+  MathToSPIRVPass.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/IR
+
+  DEPENDS
+  MLIRConversionPassIncGen
+
+  LINK_LIBS PUBLIC
+  MLIRIR
+  MLIRMath
+  MLIRPass
+  MLIRSPIRV
+  MLIRSPIRVConversion
+  MLIRSupport
+  MLIRTransformUtils
+  )
+

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

+//===- MathToSPIRV.cpp - Math to SPIR-V Patterns --------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements patterns to convert Math dialect to SPIR-V dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/Math/IR/Math.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "math-to-spirv-pattern"
+
+using namespace mlir;
+
+//===----------------------------------------------------------------------===//
+// Operation conversion
+//===----------------------------------------------------------------------===//
+
+// Note that DRR cannot be used for the patterns in this file: we may need to
+// convert type along the way, which requires ConversionPattern. DRR generates
+// normal RewritePattern.
+
+namespace {
+
+/// Converts unary and binary standard operations to SPIR-V operations.
+template <typename StdOp, typename SPIRVOp>
+class UnaryAndBinaryOpPattern final : public OpConversionPattern<StdOp> {
+public:
+  using OpConversionPattern<StdOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(StdOp operation, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    assert(operands.size() <= 2);
+    auto dstType = this->getTypeConverter()->convertType(operation.getType());
+    if (!dstType)
+      return failure();
+    if (SPIRVOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&
+        dstType != operation.getType()) {
+      return operation.emitError(
+          "bitwidth emulation is not implemented yet on unsigned op");
+    }
+    rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType, operands);
+    return success();
+  }
+};
+
+/// Converts math.log1p to SPIR-V ops.
+///
+/// SPIR-V does not have a direct operations for log(1+x). Explicitly lower to
+/// these operations.
+class Log1pOpPattern final : public OpConversionPattern<math::Log1pOp> {
+public:
+  using OpConversionPattern<math::Log1pOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(math::Log1pOp operation, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    assert(operands.size() == 1);
+    Location loc = operation.getLoc();
+    auto type =
+        this->getTypeConverter()->convertType(operation.operand().getType());
+    auto one = spirv::ConstantOp::getOne(type, operation.getLoc(), rewriter);
+    auto onePlus = rewriter.create<spirv::FAddOp>(loc, one, operands[0]);
+    rewriter.replaceOpWithNewOp<spirv::GLSLLogOp>(operation, type, onePlus);
+    return success();
+  }
+};
+
+} // namespace
+
+//===----------------------------------------------------------------------===//
+// Pattern population
+//===----------------------------------------------------------------------===//
+
+namespace mlir {
+void populateMathToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
+                                 RewritePatternSet &patterns) {
+  patterns.add<Log1pOpPattern,
+               UnaryAndBinaryOpPattern<math::CosOp, spirv::GLSLCosOp>,
+               UnaryAndBinaryOpPattern<math::ExpOp, spirv::GLSLExpOp>,
+               UnaryAndBinaryOpPattern<math::LogOp, spirv::GLSLLogOp>,
+               UnaryAndBinaryOpPattern<math::RsqrtOp, spirv::GLSLInverseSqrtOp>,
+               UnaryAndBinaryOpPattern<math::PowFOp, spirv::GLSLPowOp>,
+               UnaryAndBinaryOpPattern<math::SinOp, spirv::GLSLSinOp>,
+               UnaryAndBinaryOpPattern<math::SqrtOp, spirv::GLSLSqrtOp>,
+               UnaryAndBinaryOpPattern<math::TanhOp, spirv::GLSLTanhOp>>(
+      typeConverter, patterns.getContext());
+}
+
+} // namespace mlir

mlir/lib/Conversion/MathToSPIRV/MathToSPIRVPass.cpp

+//===- MathToSPIRVPass.cpp - Math to SPIR-V Passes ------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a pass to convert standard dialect to SPIR-V dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Conversion/MathToSPIRV/MathToSPIRVPass.h"
+#include "../PassDetail.h"
+#include "mlir/Conversion/MathToSPIRV/MathToSPIRV.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
+#include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
+
+using namespace mlir;
+
+namespace {
+/// A pass converting MLIR Math operations into the SPIR-V dialect.
+class ConvertMathToSPIRVPass
+    : public ConvertMathToSPIRVBase<ConvertMathToSPIRVPass> {
+  void runOnOperation() override;
+};
+} // namespace
+
+void ConvertMathToSPIRVPass::runOnOperation() {
+  MLIRContext *context = &getContext();
+  ModuleOp module = getOperation();
+
+  auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
+  std::unique_ptr<ConversionTarget> target =
+      SPIRVConversionTarget::get(targetAttr);
+
+  SPIRVTypeConverter typeConverter(targetAttr);
+
+  RewritePatternSet patterns(context);
+  populateMathToSPIRVPatterns(typeConverter, patterns);
+
+  if (failed(applyPartialConversion(module, *target, std::move(patterns))))
+    return signalPassFailure();
+}
+
+std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertMathToSPIRVPass() {
+  return std::make_unique<ConvertMathToSPIRVPass>();
+}

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

 //===- StandardToSPIRV.cpp - Standard to SPIR-V Patterns ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements patterns to convert standard dialect to SPIR-V dialect.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Transforms/SPIRVConversion.h"
 #include "mlir/Dialect/SPIRV/Utils/LayoutUtils.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/AffineMap.h"
if (SPIRVOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&
       return operation.emitError(
           "bitwidth emulation is not implemented yet on unsigned op");
     }
     rewriter.template replaceOpWithNewOp<SPIRVOp>(operation, dstType, operands);
     return success();
   }
 };
 
-/// Converts math.log1p to SPIR-V ops.
-///
-/// SPIR-V does not have a direct operations for log(1+x). Explicitly lower to
-/// these operations.
-class Log1pOpPattern final : public OpConversionPattern<math::Log1pOp> {
-public:
-  using OpConversionPattern<math::Log1pOp>::OpConversionPattern;
-
-  LogicalResult
-  matchAndRewrite(math::Log1pOp operation, ArrayRef<Value> operands,
-                  ConversionPatternRewriter &rewriter) const override {
-    assert(operands.size() == 1);
-    Location loc = operation.getLoc();
-    auto type =
-        this->getTypeConverter()->convertType(operation.operand().getType());
-    auto one = spirv::ConstantOp::getOne(type, operation.getLoc(), rewriter);
-    auto onePlus = rewriter.create<spirv::FAddOp>(loc, one, operands[0]);
-    rewriter.replaceOpWithNewOp<spirv::GLSLLogOp>(operation, type, onePlus);
-    return success();
-  }
-};
-
 /// Converts std.remi_signed to SPIR-V ops.
 ///
 /// This cannot be merged into the template unary/binary pattern due to
 /// Vulkan restrictions over spv.SRem and spv.SMod.
 class SignedRemIOpPattern final : public OpConversionPattern<SignedRemIOp> {
 public:
   using OpConversionPattern<SignedRemIOp>::OpConversionPattern;
 

 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 void populateStandardToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                      RewritePatternSet &patterns) {
   MLIRContext *context = patterns.getContext();
 
   patterns.add<
-      // Math dialect operations.
-      // TODO: Move to separate pass.
-      UnaryAndBinaryOpPattern<math::CosOp, spirv::GLSLCosOp>,
-      UnaryAndBinaryOpPattern<math::ExpOp, spirv::GLSLExpOp>,
-      UnaryAndBinaryOpPattern<math::LogOp, spirv::GLSLLogOp>,
-      UnaryAndBinaryOpPattern<math::RsqrtOp, spirv::GLSLInverseSqrtOp>,
-      UnaryAndBinaryOpPattern<math::PowFOp, spirv::GLSLPowOp>,
-      UnaryAndBinaryOpPattern<math::SinOp, spirv::GLSLSinOp>,
-      UnaryAndBinaryOpPattern<math::SqrtOp, spirv::GLSLSqrtOp>,
-      UnaryAndBinaryOpPattern<math::TanhOp, spirv::GLSLTanhOp>,
-
       // Unary and binary patterns
       BitwiseOpPattern<AndOp, spirv::LogicalAndOp, spirv::BitwiseAndOp>,
       BitwiseOpPattern<OrOp, spirv::LogicalOrOp, spirv::BitwiseOrOp>,
       UnaryAndBinaryOpPattern<AbsFOp, spirv::GLSLFAbsOp>,
       UnaryAndBinaryOpPattern<AddFOp, spirv::FAddOp>,
       UnaryAndBinaryOpPattern<AddIOp, spirv::IAddOp>,
       UnaryAndBinaryOpPattern<CeilFOp, spirv::GLSLCeilOp>,
       UnaryAndBinaryOpPattern<DivFOp, spirv::FDivOp>,
       UnaryAndBinaryOpPattern<FloorFOp, spirv::GLSLFloorOp>,
       UnaryAndBinaryOpPattern<MulFOp, spirv::FMulOp>,
       UnaryAndBinaryOpPattern<MulIOp, spirv::IMulOp>,
       UnaryAndBinaryOpPattern<NegFOp, spirv::FNegateOp>,
       UnaryAndBinaryOpPattern<RemFOp, spirv::FRemOp>,
       UnaryAndBinaryOpPattern<ShiftLeftOp, spirv::ShiftLeftLogicalOp>,
       UnaryAndBinaryOpPattern<SignedDivIOp, spirv::SDivOp>,
       UnaryAndBinaryOpPattern<SignedShiftRightOp,
                               spirv::ShiftRightArithmeticOp>,
       UnaryAndBinaryOpPattern<SubIOp, spirv::ISubOp>,
       UnaryAndBinaryOpPattern<SubFOp, spirv::FSubOp>,
       UnaryAndBinaryOpPattern<UnsignedDivIOp, spirv::UDivOp>,
       UnaryAndBinaryOpPattern<UnsignedRemIOp, spirv::UModOp>,
       UnaryAndBinaryOpPattern<UnsignedShiftRightOp, spirv::ShiftRightLogicalOp>,
-      Log1pOpPattern, SignedRemIOpPattern, XOrOpPattern, BoolXOrOpPattern,
+      SignedRemIOpPattern, XOrOpPattern, BoolXOrOpPattern,
 
       // Comparison patterns
       BoolCmpIOpPattern, CmpFOpPattern, CmpFOpNanNonePattern, CmpIOpPattern,
 
       // Constant patterns
       ConstantCompositeOpPattern, ConstantScalarOpPattern,
 
       // Memory patterns

mlir/test/Conversion/MathToSPIRV/math-to-spirv.mlir

+// RUN: mlir-opt -split-input-file -convert-math-to-spirv -verify-diagnostics %s -o - | FileCheck %s
+
+// CHECK-LABEL: @float32_unary_scalar
+func @float32_unary_scalar(%arg0: f32) {
+  // CHECK: spv.GLSL.Cos %{{.*}}: f32
+  %0 = math.cos %arg0 : f32
+  // CHECK: spv.GLSL.Exp %{{.*}}: f32
+  %1 = math.exp %arg0 : f32
+  // CHECK: spv.GLSL.Log %{{.*}}: f32
+  %2 = math.log %arg0 : f32
+  // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
+  // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
+  // CHECK: spv.GLSL.Log %[[ADDONE]]
+  %3 = math.log1p %arg0 : f32
+  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: f32
+  %4 = math.rsqrt %arg0 : f32
+  // CHECK: spv.GLSL.Sqrt %{{.*}}: f32
+  %5 = math.sqrt %arg0 : f32
+  // CHECK: spv.GLSL.Tanh %{{.*}}: f32
+  %6 = math.tanh %arg0 : f32
+  // CHECK: spv.GLSL.Sin %{{.*}}: f32
+  %7 = math.sin %arg0 : f32
+  return
+}
+
+// CHECK-LABEL: @float32_unary_vector
+func @float32_unary_vector(%arg0: vector<3xf32>) {
+  // CHECK: spv.GLSL.Cos %{{.*}}: vector<3xf32>
+  %0 = math.cos %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.Exp %{{.*}}: vector<3xf32>
+  %1 = math.exp %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.Log %{{.*}}: vector<3xf32>
+  %2 = math.log %arg0 : vector<3xf32>
+  // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00> : vector<3xf32>
+  // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
+  // CHECK: spv.GLSL.Log %[[ADDONE]]
+  %3 = math.log1p %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: vector<3xf32>
+  %4 = math.rsqrt %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.Sqrt %{{.*}}: vector<3xf32>
+  %5 = math.sqrt %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.Tanh %{{.*}}: vector<3xf32>
+  %6 = math.tanh %arg0 : vector<3xf32>
+  // CHECK: spv.GLSL.Sin %{{.*}}: vector<3xf32>
+  %7 = math.sin %arg0 : vector<3xf32>
+  return
+}
+
+// CHECK-LABEL: @float32_binary_scalar
+func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
+  // CHECK: spv.GLSL.Pow %{{.*}}: f32
+  %0 = math.powf %lhs, %rhs : f32
+  return
+}
+
+// CHECK-LABEL: @float32_binary_vector
+func @float32_binary_vector(%lhs: vector<4xf32>, %rhs: vector<4xf32>) {
+  // CHECK: spv.GLSL.Pow %{{.*}}: vector<4xf32>
+  %0 = math.powf %lhs, %rhs : vector<4xf32>
+  return
+}

mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir

 
 // Check float unary operation conversions.
 // CHECK-LABEL: @float32_unary_scalar
 func @float32_unary_scalar(%arg0: f32) {
   // CHECK: spv.GLSL.FAbs %{{.*}}: f32
   %0 = absf %arg0 : f32
   // CHECK: spv.GLSL.Ceil %{{.*}}: f32
   %1 = ceilf %arg0 : f32
-  // CHECK: spv.GLSL.Cos %{{.*}}: f32
-  %2 = math.cos %arg0 : f32
-  // CHECK: spv.GLSL.Exp %{{.*}}: f32
-  %3 = math.exp %arg0 : f32
-  // CHECK: spv.GLSL.Log %{{.*}}: f32
-  %4 = math.log %arg0 : f32
-  // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
-  // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
-  // CHECK: spv.GLSL.Log %[[ADDONE]]
-  %40 = math.log1p %arg0 : f32
   // CHECK: spv.FNegate %{{.*}}: f32
   %5 = negf %arg0 : f32
-  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: f32
-  %6 = math.rsqrt %arg0 : f32
-  // CHECK: spv.GLSL.Sqrt %{{.*}}: f32
-  %7 = math.sqrt %arg0 : f32
-  // CHECK: spv.GLSL.Tanh %{{.*}}: f32
-  %8 = math.tanh %arg0 : f32
-  // CHECK: spv.GLSL.Sin %{{.*}}: f32
-  %9 = math.sin %arg0 : f32
   // CHECK: spv.GLSL.Floor %{{.*}}: f32
   %10 = floorf %arg0 : f32
   return
 }
 
 // Check float binary operation conversions.
 // CHECK-LABEL: @float32_binary_scalar
 func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
   // CHECK: spv.FAdd %{{.*}}, %{{.*}}: f32
   %0 = addf %lhs, %rhs: f32
   // CHECK: spv.FSub %{{.*}}, %{{.*}}: f32
   %1 = subf %lhs, %rhs: f32
   // CHECK: spv.FMul %{{.*}}, %{{.*}}: f32
   %2 = mulf %lhs, %rhs: f32
   // CHECK: spv.FDiv %{{.*}}, %{{.*}}: f32
   %3 = divf %lhs, %rhs: f32
   // CHECK: spv.FRem %{{.*}}, %{{.*}}: f32
   %4 = remf %lhs, %rhs: f32
-  // CHECK: spv.GLSL.Pow %{{.*}}: f32
-  %5 = math.powf %lhs, %rhs : f32
   return
 }
 
 // Check int vector types.
 // CHECK-LABEL: @int_vector234
 func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
   // CHECK: spv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
   %0 = divi_signed %arg0, %arg0: vector<2xi8>

utils/bazel/llvm-project-overlay/mlir/BUILD.bazel

deps = [
         ":GPUToROCDLTransforms",
         ":GPUToSPIRV",
         ":GPUToVulkanTransforms",
         ":LinalgToLLVM",
         ":LinalgToSPIRV",
         ":LinalgToStandard",
         ":MathToLLVM",
         ":MathToLibm",
+        ":MathToSPIRV",
         ":MemRefToLLVM",
         ":OpenACCToLLVM",
         ":OpenACCToSCF",
         ":OpenMPToLLVM",
         ":PDLToPDLInterp",
         ":SCFToGPUPass",
         ":SCFToOpenMP",
         ":SCFToSPIRV",
deps = [
         ":SPIRVUtils",
         ":Support",
         ":Transforms",
         "//llvm:Support",
     ],
 )
 
 cc_library(
+    name = "MathToSPIRV",
+    srcs = glob([
+        "lib/Conversion/MathToSPIRV/*.cpp",
+        "lib/Conversion/MathToSPIRV/*.h",
+    ]) + ["lib/Conversion/PassDetail.h"],
+    hdrs = glob([
+        "include/mlir/Conversion/MathToSPIRV/*.h",
+    ]),
+    includes = [
+        "include",
+        "lib/Conversion/MathToSPIRV",
+    ],
+    deps = [
+        ":ConversionPassIncGen",
+        ":IR",
+        ":MathDialect",
+        ":Pass",
+        ":SPIRVConversion",
+        ":SPIRVDialect",
+        ":Support",
+        ":Transforms",
+        "//llvm:Support",
+    ],
+)
+
+cc_library(
     name = "StandardToSPIRV",
     srcs = glob([
         "lib/Conversion/StandardToSPIRV/*.cpp",
         "lib/Conversion/StandardToSPIRV/*.h",
     ]) + ["lib/Conversion/PassDetail.h"],
     hdrs = glob([
         "include/mlir/Conversion/StandardToSPIRV/*.h",
     ]),
     includes = [
         "include",
         "lib/Conversion/StandardToSPIRV",
     ],
     deps = [
         ":ConversionPassIncGen",
         ":IR",
-        ":MathDialect",
         ":MemRefDialect",
         ":Pass",
         ":SPIRVConversion",
         ":SPIRVDialect",
         ":SPIRVUtils",
         ":StandardOps",
         ":Support",
         ":TensorDialect",
deps = [
         ":LinalgPassIncGen",
         ":LinalgToLLVM",
         ":LinalgToSPIRV",
         ":LinalgToStandard",
         ":LinalgTransforms",
         ":MathDialect",
         ":MathToLLVM",
         ":MathToLibm",
+        ":MathToSPIRV",
         ":MathTransforms",
         ":MemRefDialect",
         ":MemRefToLLVM",
         ":MemRefTransforms",
         ":NVVMDialect",
         ":OpenACCDialect",
         ":OpenMPDialect",
         ":OpenMPToLLVM",