[mlir][spirv] math.erf OpenCL lowering

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

 // 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.";
+def SPV_OCLErfOp : SPV_OCLUnaryArithmeticOp<"erf", 18, SPV_Float> {
+  let summary = [{
+    Error function of x encountered in integrating the normal distribution.
+  }];
 
   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 `:`
+    erf-op ::= ssa-id `=` `spv.OCL.erf` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.tanh %0 : f32
-    %3 = spv.OCL.tanh %1 : vector<3xf16>
+    %2 = spv.OCL.erf %0 : f32
+    %3 = spv.OCL.erf %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
 def SPV_OCLCeilOp : SPV_OCLUnaryArithmeticOp<"ceil", 12, SPV_Float> {
   let summary = [{
let description = [{
     %2 = spv.OCL.sqrt %0 : f32
     %3 = spv.OCL.sqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
+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_OCLSAbsOp : SPV_OCLUnaryArithmeticOp<"s_abs", 141, SPV_Integer> {
   let summary = "Absolute value of operand";
 
   let description = [{
     Returns |x|, where x is treated as signed integer.
 
     Result Type and x must be integer or vector(2,3,4,8,16) of
     integer values.

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

patterns.add<
       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::ErfOp, spirv::OCLErfOp>,
                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/MathToSPIRV/math-to-opencl-spirv.mlir

func @float32_unary_scalar(%arg0: f32) {
   // CHECK: spv.OCL.sin %{{.*}}: f32
   %7 = math.sin %arg0 : f32
   // CHECK: spv.OCL.fabs %{{.*}}: f32
   %8 = math.abs %arg0 : f32
   // CHECK: spv.OCL.ceil %{{.*}}: f32
   %9 = math.ceil %arg0 : f32
   // CHECK: spv.OCL.floor %{{.*}}: f32
   %10 = math.floor %arg0 : f32
+  // CHECK: spv.OCL.erf %{{.*}}: f32
+  %11 = math.erf %arg0 : f32
   return
 }
 
 // CHECK-LABEL: @float32_unary_vector
 func @float32_unary_vector(%arg0: vector<3xf32>) {
   // CHECK: spv.OCL.cos %{{.*}}: vector<3xf32>
   %0 = math.cos %arg0 : vector<3xf32>
   // CHECK: spv.OCL.exp %{{.*}}: vector<3xf32>

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

spv.func @float_insts(%arg0 : f32) "None" {
     // 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
+    // CHECK: {{%.*}} = spv.OCL.erf {{%.*}} : f32
+    %10 = spv.OCL.erf %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
   }
 }