[mlir][spirv] Add math to OpenCL conversion

[antiagainst]

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

20 ↗

(On Diff #386872)

There is no need to create separate passes; should use the target environment.

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

80–95

This isn't the proper way to handle conversions; we should rely on the target environment. Let me explain a bit more on this here:

The conversion patterns to SPIR-V should not concern about the legality of the generated op in the target environment. That's entirely the job of the dialect conversion framework. In SPIR-V, we clearly define the required version/extension/capability for all the ops and then wires up them to the dialect conversion legality check. When the dialect conversion happens, _all_ patterns will be tried (both for Vulkan and OpenCL) but _only_ those patterns generating ops allowed in the target environment can succeed because of the legality check there. By this, we have a clear separation of concerns and all the patterns can be written in a simple way, without requiring each pattern to consider its interaction with other patterns and the target environment. If you'd like to control which patterns apply, you should set the proper target environment.

There is actually one example for CmpFOp showing how to write patterns in such a way and selectively apply patterns according to the target environment. (Well sort of I guess. ;-P)

• Patterns: https://github.com/llvm/llvm-project/blob/92fc60bc629b02eea31853223459ca5d78bc5dd4/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp#L703-L747
• Registration: https://github.com/llvm/llvm-project/blob/92fc60bc629b02eea31853223459ca5d78bc5dd4/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp#L789-L796
• Tests: https://github.com/llvm/llvm-project/blob/92fc60bc629b02eea31853223459ca5d78bc5dd4/mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir#L295-L332

In the above we are trying to apply patterns selectively according to the target environment. The difference there though is it is for core vs kernel. So we use pattern benefits to make sure kernel patterns prevail if kernel is allowed in the target environment. Those two patterns are written entirely without knowledge of that and the populate* entry point does not have the switch for it.

In this patch we are trying to do it for vulkan for opencl; they are of equal footing from SPIR-V conversion's perspective; so we don't need to adjust benefits. We just need to make sure the version/extension/capability requirements are properly declared in all ops and you have the proper target environment when doing conversion. Then everything should just work.

I guess right now we miss proper version/extension/capability declarations for those extended instruction set ops. If you put the following to the main SPV_OCLOp definition:

list<Availability> availability = [
  MinVersion<SPV_V_1_0>,
  MaxVersion<SPV_V_1_5>,
  Extension<[]>,
  Capability<[Extension]>
];

It should fix. (Also need to put Shader capability requirements for all GLSL extended ops.)

Does this make sense? Happy to explain more if anything is unclear. :)

[Hardcode84]

use capability

[antiagainst]

Awesome, thanks!

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V GLSL 4.50 opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all GLSL ops.
 class SPV_GLSLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
-  SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits>;
+  SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits> {
+
+  let availability = [
+    MinVersion<SPV_V_1_0>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_Shader]>
+  ];
+}
 
 // Base class for GLSL unary ops.
 class SPV_GLSLUnaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<OpTrait> traits = []> :
   SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td

 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V OpenCL opcode specification.
 //===----------------------------------------------------------------------===//
 
 // Base class for all OpenCL ops.
 class SPV_OCLOp<string mnemonic, int opcode, list<OpTrait> traits = []> :
-  SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits>;
+  SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits> {
+
+  let availability = [
+    MinVersion<SPV_V_1_0>,
+    MaxVersion<SPV_V_1_5>,
+    Extension<[]>,
+    Capability<[SPV_C_Kernel]>
+  ];
+}
 
 // Base class for OpenCL unary ops.
 class SPV_OCLUnaryOp<string mnemonic, int opcode, Type resultType,
                      Type operandType, list<OpTrait> traits = []> :
   SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand

 // Base class for OpenCL Binary arithmetic ops where operand types and
 // return type matches.
 class SPV_OCLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<OpTrait> traits = []> :
   SPV_OCLBinaryOp<mnemonic, opcode, type, type, traits>;
 
 // -----
 
+def SPV_OCLTanhOp : SPV_OCLUnaryArithmeticOp<"tanh", 63, SPV_Float> {
+  let summary = "Compute hyperbolic tangent of x radians.";
+
+  let description = [{
+    Result Type and x must be floating-point or vector(2,3,4,8,16) of
+    floating-point values.
+
+    All of the operands, including the Result Type operand, must be of the
+    same type.
+
+    <!-- End of AutoGen section -->
+
+    ```
+    float-scalar-vector-type ::= float-type |
+                                 `vector<` integer-literal `x` float-type `>`
+    tanh-op ::= ssa-id `=` `spv.OCL.tanh` ssa-use `:`
+               float-scalar-vector-type
+    ```mlir
+
+    #### Example:
+
+    ```
+    %2 = spv.OCL.tanh %0 : f32
+    %3 = spv.OCL.tanh %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
+def SPV_OCLCeilOp : SPV_OCLUnaryArithmeticOp<"ceil", 12, SPV_Float> {
+  let summary = [{
+    Round x to integral value using the round to positive infinity rounding
+    mode.
+  }];
+
+  let description = [{
+    Result Type and x must be floating-point or vector(2,3,4,8,16) of
+    floating-point values.
+
+    All of the operands, including the Result Type operand, must be of the
+    same type.
+
+    <!-- End of AutoGen section -->
+
+    ```
+    float-scalar-vector-type ::= float-type |
+                                 `vector<` integer-literal `x` float-type `>`
+    ceil-op ::= ssa-id `=` `spv.OCL.ceil` ssa-use `:`
+               float-scalar-vector-type
+    ```mlir
+
+    #### Example:
+
+    ```
+    %2 = spv.OCL.ceil %0 : f32
+    %3 = spv.OCL.ceil %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
 def SPV_OCLCosOp : SPV_OCLUnaryArithmeticOp<"cos", 14, SPV_Float> {
   let summary = "Compute the cosine of x radians.";
 
   let description = [{
     Result Type and x must be floating-point or vector(2,3,4,8,16) of
     floating-point values.
 
     All of the operands, including the Result Type operand, must be of the
     same type.
 
     <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    abs-op ::= ssa-id `=` `spv.OCL.cos` ssa-use `:`
+    cos-op ::= ssa-id `=` `spv.OCL.cos` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
     %2 = spv.OCL.cos %0 : f32
     %3 = spv.OCL.cos %1 : vector<3xf16>
let description = [{
     %2 = spv.OCL.fabs %0 : f32
     %3 = spv.OCL.fabs %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
+def SPV_OCLFloorOp : SPV_OCLUnaryArithmeticOp<"floor", 25, SPV_Float> {
+  let summary = [{
+    Round x to the integral value using the round to negative infinity
+    rounding mode.
+  }];
+
+  let description = [{
+    Result Type and x must be floating-point or vector(2,3,4,8,16) of
+    floating-point values.
+
+    All of the operands, including the Result Type operand, must be of the
+    same type.
+
+    <!-- End of AutoGen section -->
+
+    ```
+    float-scalar-vector-type ::= float-type |
+                                 `vector<` integer-literal `x` float-type `>`
+    floor-op ::= ssa-id `=` `spv.OCL.floor` ssa-use `:`
+               float-scalar-vector-type
+    ```mlir
+
+    #### Example:
+
+    ```
+    %2 = spv.OCL.floor %0 : f32
+    %3 = spv.OCL.ceifloorl %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
 def SPV_OCLLogOp : SPV_OCLUnaryArithmeticOp<"log", 37, SPV_Float> {
   let summary = "Compute the natural logarithm of x.";
 
   let description = [{
     Result Type and x must be floating-point or vector(2,3,4,8,16) of
     floating-point values.
 
     All of the operands, including the Result Type operand, must be of the
     same type.
 
     <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    abs-op ::= ssa-id `=` `spv.OCL.log` ssa-use `:`
+    log-op ::= ssa-id `=` `spv.OCL.log` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
     %2 = spv.OCL.log %0 : f32
     %3 = spv.OCL.log %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
+def SPV_OCLPowOp : SPV_OCLBinaryArithmeticOp<"pow", 48, SPV_Float> {
+  let summary = "Compute x to the power y.";
+
+  let description = [{
+    Result Type, x and y must be floating-point or vector(2,3,4,8,16) of
+    floating-point values.
+
+    All of the operands, including the Result Type operand, must be of the
+    same type.
+
+    <!-- End of AutoGen section -->
+
+    ```
+    restricted-float-scalar-type ::=  `f16` | `f32`
+    restricted-float-scalar-vector-type ::=
+      restricted-float-scalar-type |
+      `vector<` integer-literal `x` restricted-float-scalar-type `>`
+    pow-op ::= ssa-id `=` `spv.OCL.pow` ssa-use `:`
+               restricted-float-scalar-vector-type
+    ```
+    #### Example:
+
+    ```mlir
+    %2 = spv.OCL.pow %0, %1 : f32
+    %3 = spv.OCL.pow %0, %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
+def SPV_OCLRsqrtOp : SPV_OCLUnaryArithmeticOp<"rsqrt", 56, SPV_Float> {
+  let summary = "Compute inverse square root of x.";
+
+  let description = [{
+    Result Type and x must be floating-point or vector(2,3,4,8,16) of
+    floating-point values.
+
+    All of the operands, including the Result Type operand, must be of the
+    same type.
+
+    <!-- End of AutoGen section -->
+
+    ```
+    float-scalar-vector-type ::= float-type |
+                                 `vector<` integer-literal `x` float-type `>`
+    rsqrt-op ::= ssa-id `=` `spv.OCL.rsqrt` ssa-use `:`
+               float-scalar-vector-type
+    ```mlir
+
+    #### Example:
+
+    ```
+    %2 = spv.OCL.rsqrt %0 : f32
+    %3 = spv.OCL.rsqrt %1 : vector<3xf16>
+    ```
+  }];
+}
+
+// -----
+
 def SPV_OCLSinOp : SPV_OCLUnaryArithmeticOp<"sin", 57, SPV_Float> {
   let summary = "Compute sine of x radians.";
 
   let description = [{
     Result Type and x must be floating-point or vector(2,3,4,8,16) of
     floating-point values.
 
     All of the operands, including the Result Type operand, must be of the
     same type.
 
     <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    abs-op ::= ssa-id `=` `spv.OCL.sin` ssa-use `:`
+    sin-op ::= ssa-id `=` `spv.OCL.sin` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
     %2 = spv.OCL.sin %0 : f32
     %3 = spv.OCL.sin %1 : vector<3xf16>
let description = [{
     All of the operands, including the Result Type operand, must be of the
     same type.
 
     <!-- End of AutoGen section -->
 
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    abs-op ::= ssa-id `=` `spv.OCL.sqrt` ssa-use `:`
+    sqrt-op ::= ssa-id `=` `spv.OCL.sqrt` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
     %2 = spv.OCL.sqrt %0 : f32
     %3 = spv.OCL.sqrt %1 : vector<3xf16>

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

 // convert type along the way, which requires ConversionPattern. DRR generates
 // normal RewritePattern.
 
 namespace {
 /// Converts math.log1p to SPIR-V ops.
 ///
 /// SPIR-V does not have a direct operations for log(1+x). Explicitly lower to
 /// these operations.
+template <typename LogOp>
 class Log1pOpPattern final : public OpConversionPattern<math::Log1pOp> {
 public:
   using OpConversionPattern<math::Log1pOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(math::Log1pOp operation, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     assert(adaptor.getOperands().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, adaptor.getOperands()[0]);
-    rewriter.replaceOpWithNewOp<spirv::GLSLLogOp>(operation, type, onePlus);
+    rewriter.replaceOpWithNewOp<LogOp>(operation, type, onePlus);
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 void populateMathToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                  RewritePatternSet &patterns) {
+
+  // GLSL patterns
   patterns.add<
-      Log1pOpPattern,
+      Log1pOpPattern<spirv::GLSLLogOp>,
       spirv::UnaryAndBinaryOpPattern<math::AbsOp, spirv::GLSLFAbsOp>,
       spirv::UnaryAndBinaryOpPattern<math::CeilOp, spirv::GLSLCeilOp>,
       spirv::UnaryAndBinaryOpPattern<math::CosOp, spirv::GLSLCosOp>,
       spirv::UnaryAndBinaryOpPattern<math::ExpOp, spirv::GLSLExpOp>,
       spirv::UnaryAndBinaryOpPattern<math::FloorOp, spirv::GLSLFloorOp>,
       spirv::UnaryAndBinaryOpPattern<math::LogOp, spirv::GLSLLogOp>,
       spirv::UnaryAndBinaryOpPattern<math::PowFOp, spirv::GLSLPowOp>,
       spirv::UnaryAndBinaryOpPattern<math::RsqrtOp, spirv::GLSLInverseSqrtOp>,
       spirv::UnaryAndBinaryOpPattern<math::SinOp, spirv::GLSLSinOp>,
       spirv::UnaryAndBinaryOpPattern<math::SqrtOp, spirv::GLSLSqrtOp>,
       spirv::UnaryAndBinaryOpPattern<math::TanhOp, spirv::GLSLTanhOp>>(
       typeConverter, patterns.getContext());
+
+  // OpenCL patterns
+  patterns.add<Log1pOpPattern<spirv::OCLLogOp>,
+               spirv::UnaryAndBinaryOpPattern<math::AbsOp, spirv::OCLFAbsOp>,
+               spirv::UnaryAndBinaryOpPattern<math::CeilOp, spirv::OCLCeilOp>,
+               spirv::UnaryAndBinaryOpPattern<math::CosOp, spirv::OCLCosOp>,
+               spirv::UnaryAndBinaryOpPattern<math::ExpOp, spirv::OCLExpOp>,
+               spirv::UnaryAndBinaryOpPattern<math::FloorOp, spirv::OCLFloorOp>,
+               spirv::UnaryAndBinaryOpPattern<math::LogOp, spirv::OCLLogOp>,
+               spirv::UnaryAndBinaryOpPattern<math::PowFOp, spirv::OCLPowOp>,
+               spirv::UnaryAndBinaryOpPattern<math::RsqrtOp, spirv::OCLRsqrtOp>,
+               spirv::UnaryAndBinaryOpPattern<math::SinOp, spirv::OCLSinOp>,
+               spirv::UnaryAndBinaryOpPattern<math::SqrtOp, spirv::OCLSqrtOp>,
+               spirv::UnaryAndBinaryOpPattern<math::TanhOp, spirv::OCLTanhOp>>(
+      typeConverter, patterns.getContext());
 }
 
 } // namespace mlir

mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir

 // RUN: mlir-opt -split-input-file -convert-std-to-spirv -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // arithmetic ops
 //===----------------------------------------------------------------------===//
 
 module attributes {
   spv.target_env = #spv.target_env<
-    #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, {}>
+    #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, {}>
 } {
 
 // Check integer operation conversions.
 // CHECK-LABEL: @int32_scalar
 func @int32_scalar(%lhs: i32, %rhs: i32) {
   // CHECK: spv.IAdd %{{.*}}, %{{.*}}: i32
   %0 = arith.addi %lhs, %rhs: i32
   // CHECK: spv.ISub %{{.*}}, %{{.*}}: i32

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

 // RUN: mlir-opt -split-input-file -convert-math-to-spirv -verify-diagnostics %s -o - | FileCheck %s
 
+module attributes { spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], []>, {}> } {
+
 // 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-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
 }
+
+} // end module

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

 // RUN: mlir-opt -split-input-file -convert-math-to-spirv -verify-diagnostics %s -o - | FileCheck %s
 
+module attributes { spv.target_env = #spv.target_env<#spv.vce<v1.0, [Kernel], []>, {}> } {
+
 // CHECK-LABEL: @float32_unary_scalar
 func @float32_unary_scalar(%arg0: f32) {
-  // CHECK: spv.GLSL.Cos %{{.*}}: f32
+  // CHECK: spv.OCL.cos %{{.*}}: f32
   %0 = math.cos %arg0 : f32
-  // CHECK: spv.GLSL.Exp %{{.*}}: f32
+  // CHECK: spv.OCL.exp %{{.*}}: f32
   %1 = math.exp %arg0 : f32
-  // CHECK: spv.GLSL.Log %{{.*}}: f32
+  // CHECK: spv.OCL.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]]
+  // CHECK: spv.OCL.log %[[ADDONE]]
   %3 = math.log1p %arg0 : f32
-  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: f32
+  // CHECK: spv.OCL.rsqrt %{{.*}}: f32
   %4 = math.rsqrt %arg0 : f32
-  // CHECK: spv.GLSL.Sqrt %{{.*}}: f32
+  // CHECK: spv.OCL.sqrt %{{.*}}: f32
   %5 = math.sqrt %arg0 : f32
-  // CHECK: spv.GLSL.Tanh %{{.*}}: f32
+  // CHECK: spv.OCL.tanh %{{.*}}: f32
   %6 = math.tanh %arg0 : f32
-  // CHECK: spv.GLSL.Sin %{{.*}}: f32
+  // CHECK: spv.OCL.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>
+  // CHECK: spv.OCL.cos %{{.*}}: vector<3xf32>
   %0 = math.cos %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Exp %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.exp %{{.*}}: vector<3xf32>
   %1 = math.exp %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Log %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.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]]
+  // CHECK: spv.OCL.log %[[ADDONE]]
   %3 = math.log1p %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.rsqrt %{{.*}}: vector<3xf32>
   %4 = math.rsqrt %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Sqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.sqrt %{{.*}}: vector<3xf32>
   %5 = math.sqrt %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Tanh %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.tanh %{{.*}}: vector<3xf32>
   %6 = math.tanh %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Sin %{{.*}}: vector<3xf32>
+  // CHECK: spv.OCL.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
+  // CHECK: spv.OCL.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>
+  // CHECK: spv.OCL.pow %{{.*}}: vector<4xf32>
   %0 = math.powf %lhs, %rhs : vector<4xf32>
   return
 }
+
+} // end module

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

 // RUN: mlir-opt -split-input-file -convert-std-to-spirv -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
 // std.select
 //===----------------------------------------------------------------------===//
 
 module attributes {
   spv.target_env = #spv.target_env<
-    #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>, {}>
+    #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64, Shader], []>, {}>
 } {
 
 // Check integer operation conversions.
 // CHECK-LABEL: @int32_scalar
 func @int32_scalar(%lhs: i32, %rhs: i32) {
   // CHECK: spv.IAdd %{{.*}}, %{{.*}}: i32
   %0 = arith.addi %lhs, %rhs: i32
   // CHECK: spv.ISub %{{.*}}, %{{.*}}: i32

mlir/test/Target/SPIRV/ocl-ops.mlir

 // RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
 
 spv.module Physical64 OpenCL requires #spv.vce<v1.0, [Kernel, Addresses], []> {
   spv.func @float_insts(%arg0 : f32) "None" {
     // CHECK: {{%.*}} = spv.OCL.exp {{%.*}} : f32
     %0 = spv.OCL.exp %arg0 : f32
     // CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : f32
     %1 = spv.OCL.fabs %arg0 : f32
     // CHECK: {{%.*}} = spv.OCL.sin {{%.*}} : f32
     %2 = spv.OCL.sin %arg0 : f32
     // CHECK: {{%.*}} = spv.OCL.cos {{%.*}} : f32
     %3 = spv.OCL.cos %arg0 : f32
     // CHECK: {{%.*}} = spv.OCL.log {{%.*}} : f32
     %4 = spv.OCL.log %arg0 : f32
     // CHECK: {{%.*}} = spv.OCL.sqrt {{%.*}} : f32
     %5 = spv.OCL.sqrt %arg0 : f32
+    // CHECK: {{%.*}} = spv.OCL.ceil {{%.*}} : f32
+    %6 = spv.OCL.ceil %arg0 : f32
+    // CHECK: {{%.*}} = spv.OCL.floor {{%.*}} : f32
+    %7 = spv.OCL.floor %arg0 : f32
+    // CHECK: {{%.*}} = spv.OCL.pow {{%.*}}, {{%.*}} : f32
+    %8 = spv.OCL.pow %arg0, %arg0 : f32
+    // CHECK: {{%.*}} = spv.OCL.rsqrt {{%.*}} : f32
+    %9 = spv.OCL.rsqrt %arg0 : f32
     spv.Return
   }
 
   spv.func @integer_insts(%arg0 : i32) "None" {
     // CHECK: {{%.*}} = spv.OCL.s_abs {{%.*}} : i32
     %0 = spv.OCL.s_abs %arg0 : i32
     spv.Return
   }
   
   spv.func @vector_size16(%arg0 : vector<16xf32>) "None" {
     // CHECK: {{%.*}} = spv.OCL.fabs {{%.*}} : vector<16xf32>
     %0 = spv.OCL.fabs %arg0 : vector<16xf32>
     spv.Return
   }
 }