[mlir][spirv] Rename spv.ocl to spv.cl. NFC.

[kuhar]

Summary

This is to improve the consistency within the SPIR-V dialect and to make op names a bit shorter.

[antiagainst]

Awesome, thanks!

mlir/docs/SPIRVToLLVMDialectConversion.md

 
 ### Not implemented ops
 
 There is no support of the following ops:
 
 *   All atomic ops
 *   All group ops
 *   All matrix ops
-*   All OCL ops
+*   All CL ops
 
 As well as:
 
 *   spv.CompositeConstruct
 *   spv.ControlBarrier
 *   spv.CopyMemory
 *   spv.FMod
 *   spv.GLSL.Acos

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

-//===- SPIRVOCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===//
+//===- SPIRVCLOps.td - OpenCL extended insts spec file ----*- tablegen -*-===//
 //
 // 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 is the op definition spec of OpenCL extension ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_IR_OCL_OPS
-#define MLIR_DIALECT_SPIRV_IR_OCL_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_CL_OPS
+#define MLIR_DIALECT_SPIRV_IR_CL_OPS
 
 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<Trait> traits = []> :
-  SPV_ExtInstOp<mnemonic, "OCL", "OpenCL.std", opcode, traits> {
+class SPV_CLOp<string mnemonic, int opcode, list<Trait> traits = []> :
+  SPV_ExtInstOp<mnemonic, "CL", "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,
+class SPV_CLUnaryOp<string mnemonic, int opcode, Type resultType,
                      Type operandType, list<Trait> traits = []> :
-  SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let assemblyFormat = "$operand `:` type($operand) attr-dict";
 
   let hasVerifier = 0;
 }
 
 // Base class for OpenCL Unary arithmetic ops where return type matches
 // the operand type.
-class SPV_OCLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
+class SPV_CLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
                                list<Trait> traits = []> :
-  SPV_OCLUnaryOp<mnemonic, opcode, type, type,
+  SPV_CLUnaryOp<mnemonic, opcode, type, type,
                  traits # [SameOperandsAndResultType]>;
 
 // Base class for OpenCL binary ops.
-class SPV_OCLBinaryOp<string mnemonic, int opcode, Type resultType,
+class SPV_CLBinaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$lhs,
     SPV_ScalarOrVectorOf<operandType>:$rhs
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let hasVerifier = 0;
 }
 
 // Base class for OpenCL Binary arithmetic ops where operand types and
 // return type matches.
-class SPV_OCLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
+class SPV_CLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
-  SPV_OCLBinaryOp<mnemonic, opcode, type, type,
-                  traits # [SameOperandsAndResultType]> {                    
+  SPV_CLBinaryOp<mnemonic, opcode, type, type,
+                  traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 // Base class for OpenCL binary ops.
-class SPV_OCLTernaryOp<string mnemonic, int opcode, Type resultType,
+class SPV_CLTernaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPV_OCLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_CLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$x,
     SPV_ScalarOrVectorOf<operandType>:$y,
     SPV_ScalarOrVectorOf<operandType>:$z
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let hasVerifier = 0;
 }
 
 // Base class for OpenCL Ternary arithmetic ops where operand types and
 // return type matches.
-class SPV_OCLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
+class SPV_CLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
-  SPV_OCLTernaryOp<mnemonic, opcode, type, type,
+  SPV_CLTernaryOp<mnemonic, opcode, type, type,
                   traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
 
 
 // -----
 
-def SPV_OCLCeilOp : SPV_OCLUnaryArithmeticOp<"ceil", 12, SPV_Float> {
+def SPV_CLCeilOp : SPV_CLUnaryArithmeticOp<"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 `:`
+    ceil-op ::= ssa-id `=` `spv.CL.ceil` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.ceil %0 : f32
-    %3 = spv.OCL.ceil %1 : vector<3xf16>
+    %2 = spv.CL.ceil %0 : f32
+    %3 = spv.CL.ceil %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLCosOp : SPV_OCLUnaryArithmeticOp<"cos", 14, SPV_Float> {
+def SPV_CLCosOp : SPV_CLUnaryArithmeticOp<"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 `>`
-    cos-op ::= ssa-id `=` `spv.OCL.cos` ssa-use `:`
+    cos-op ::= ssa-id `=` `spv.CL.cos` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.cos %0 : f32
-    %3 = spv.OCL.cos %1 : vector<3xf16>
+    %2 = spv.CL.cos %0 : f32
+    %3 = spv.CL.cos %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLErfOp : SPV_OCLUnaryArithmeticOp<"erf", 18, SPV_Float> {
+def SPV_CLErfOp : SPV_CLUnaryArithmeticOp<"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 `>`
-    erf-op ::= ssa-id `=` `spv.OCL.erf` ssa-use `:`
+    erf-op ::= ssa-id `=` `spv.CL.erf` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.erf %0 : f32
-    %3 = spv.OCL.erf %1 : vector<3xf16>
+    %2 = spv.CL.erf %0 : f32
+    %3 = spv.CL.erf %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLExpOp : SPV_OCLUnaryArithmeticOp<"exp", 19, SPV_Float> {
+def SPV_CLExpOp : SPV_CLUnaryArithmeticOp<"exp", 19, SPV_Float> {
   let summary = "Exponentiation of Operand 1";
 
   let description = [{
     Compute the base-e exponential of x. (i.e. ex)
 
     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 `>`
-    exp-op ::= ssa-id `=` `spv.OCL.exp` ssa-use `:`
+    exp-op ::= ssa-id `=` `spv.CL.exp` ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.OCL.exp %0 : f32
-    %3 = spv.OCL.exp %1 : vector<3xf16>
+    %2 = spv.CL.exp %0 : f32
+    %3 = spv.CL.exp %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLFAbsOp : SPV_OCLUnaryArithmeticOp<"fabs", 23, SPV_Float> {
+def SPV_CLFAbsOp : SPV_CLUnaryArithmeticOp<"fabs", 23, SPV_Float> {
   let summary = "Absolute value of operand";
 
   let description = [{
     Compute the absolute value of x.
 
     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.fabs` ssa-use `:`
+    abs-op ::= ssa-id `=` `spv.CL.fabs` ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.OCL.fabs %0 : f32
-    %3 = spv.OCL.fabs %1 : vector<3xf16>
+    %2 = spv.CL.fabs %0 : f32
+    %3 = spv.CL.fabs %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLFloorOp : SPV_OCLUnaryArithmeticOp<"floor", 25, SPV_Float> {
+def SPV_CLFloorOp : SPV_CLUnaryArithmeticOp<"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 `:`
+    floor-op ::= ssa-id `=` `spv.CL.floor` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.floor %0 : f32
-    %3 = spv.OCL.ceifloorl %1 : vector<3xf16>
+    %2 = spv.CL.floor %0 : f32
+    %3 = spv.CL.ceifloorl %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLFmaOp : SPV_OCLTernaryArithmeticOp<"fma", 26, SPV_Float> {
+def SPV_CLFmaOp : SPV_CLTernaryArithmeticOp<"fma", 26, SPV_Float> {
   let summary = [{
     Compute the correctly rounded floating-point representation of the sum
     of c with the infinitely precise product of a and b. Rounding of
     intermediate products shall not occur. Edge case results are per the
     IEEE 754-2008 standard.
   }];
 
   let description = [{
     Result Type, a, b and c 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 -->
 
     ```
-    fma-op ::= ssa-id `=` `spv.OCL.fma` ssa-use, ssa-use, ssa-use `:`
+    fma-op ::= ssa-id `=` `spv.CL.fma` ssa-use, ssa-use, ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     ```
-    %0 = spv.OCL.fma %a, %b, %c : f32
-    %1 = spv.OCL.fma %a, %b, %c : vector<3xf16>
+    %0 = spv.CL.fma %a, %b, %c : f32
+    %1 = spv.CL.fma %a, %b, %c : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLLogOp : SPV_OCLUnaryArithmeticOp<"log", 37, SPV_Float> {
+def SPV_CLLogOp : SPV_CLUnaryArithmeticOp<"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 `>`
-    log-op ::= ssa-id `=` `spv.OCL.log` ssa-use `:`
+    log-op ::= ssa-id `=` `spv.CL.log` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.log %0 : f32
-    %3 = spv.OCL.log %1 : vector<3xf16>
+    %2 = spv.CL.log %0 : f32
+    %3 = spv.CL.log %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLPowOp : SPV_OCLBinaryArithmeticOp<"pow", 48, SPV_Float> {
+def SPV_CLPowOp : SPV_CLBinaryArithmeticOp<"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 `:`
+    pow-op ::= ssa-id `=` `spv.CL.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>
+    %2 = spv.CL.pow %0, %1 : f32
+    %3 = spv.CL.pow %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLRoundOp : SPV_OCLUnaryArithmeticOp<"round", 55, SPV_Float> {
+def SPV_CLRoundOp : SPV_CLUnaryArithmeticOp<"round", 55, SPV_Float> {
   let summary = [{
     Return the integral value nearest to x rounding halfway cases away from
     zero, regardless of the current rounding direction.
   }];
 
   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 `>`
-    round-op ::= ssa-id `=` `spv.OCL.round` ssa-use `:`
+    round-op ::= ssa-id `=` `spv.CL.round` ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.OCL.round %0 : f32
-    %3 = spv.OCL.round %0 : vector<3xf16>
+    %2 = spv.CL.round %0 : f32
+    %3 = spv.CL.round %0 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLRsqrtOp : SPV_OCLUnaryArithmeticOp<"rsqrt", 56, SPV_Float> {
+def SPV_CLRsqrtOp : SPV_CLUnaryArithmeticOp<"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 `:`
+    rsqrt-op ::= ssa-id `=` `spv.CL.rsqrt` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.rsqrt %0 : f32
-    %3 = spv.OCL.rsqrt %1 : vector<3xf16>
+    %2 = spv.CL.rsqrt %0 : f32
+    %3 = spv.CL.rsqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLSinOp : SPV_OCLUnaryArithmeticOp<"sin", 57, SPV_Float> {
+def SPV_CLSinOp : SPV_CLUnaryArithmeticOp<"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 `>`
-    sin-op ::= ssa-id `=` `spv.OCL.sin` ssa-use `:`
+    sin-op ::= ssa-id `=` `spv.CL.sin` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.sin %0 : f32
-    %3 = spv.OCL.sin %1 : vector<3xf16>
+    %2 = spv.CL.sin %0 : f32
+    %3 = spv.CL.sin %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLSqrtOp : SPV_OCLUnaryArithmeticOp<"sqrt", 61, SPV_Float> {
+def SPV_CLSqrtOp : SPV_CLUnaryArithmeticOp<"sqrt", 61, SPV_Float> {
   let summary = "Compute 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 `>`
-    sqrt-op ::= ssa-id `=` `spv.OCL.sqrt` ssa-use `:`
+    sqrt-op ::= ssa-id `=` `spv.CL.sqrt` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.sqrt %0 : f32
-    %3 = spv.OCL.sqrt %1 : vector<3xf16>
+    %2 = spv.CL.sqrt %0 : f32
+    %3 = spv.CL.sqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLTanhOp : SPV_OCLUnaryArithmeticOp<"tanh", 63, SPV_Float> {
+def SPV_CLTanhOp : SPV_CLUnaryArithmeticOp<"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 `:`
+    tanh-op ::= ssa-id `=` `spv.CL.tanh` ssa-use `:`
                float-scalar-vector-type
     ```mlir
 
     #### Example:
 
     ```
-    %2 = spv.OCL.tanh %0 : f32
-    %3 = spv.OCL.tanh %1 : vector<3xf16>
+    %2 = spv.CL.tanh %0 : f32
+    %3 = spv.CL.tanh %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_OCLSAbsOp : SPV_OCLUnaryArithmeticOp<"s_abs", 141, SPV_Integer> {
+def SPV_CLSAbsOp : SPV_CLUnaryArithmeticOp<"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.
 
     All of the operands, including the Result Type operand,
     must be of the same type.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    abs-op ::= ssa-id `=` `spv.OCL.s_abs` ssa-use `:`
+    abs-op ::= ssa-id `=` `spv.CL.s_abs` ssa-use `:`
                integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.OCL.s_abs %0 : i32
-    %3 = spv.OCL.s_abs %1 : vector<3xi16>
+    %2 = spv.CL.s_abs %0 : i32
+    %3 = spv.CL.s_abs %1 : vector<3xi16>
     ```
   }];
 }
 
-#endif // MLIR_DIALECT_SPIRV_IR_OCL_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_CL_OPS

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

 include "mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVGroupOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVImageOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVLogicalOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVMatrixOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVMemoryOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVMiscOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVNonUniformOps.td"
-include "mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVCLOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 #endif // MLIR_DIALECT_SPIRV_IR_OPS

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

struct RemSIOpGLSLPattern final : public OpConversionPattern<arith::RemSIOp> {
   using OpConversionPattern<arith::RemSIOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.remsi to OpenCL SPIR-V ops.
-struct RemSIOpOCLPattern final : public OpConversionPattern<arith::RemSIOp> {
+struct RemSIOpCLPattern final : public OpConversionPattern<arith::RemSIOp> {
   using OpConversionPattern<arith::RemSIOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts bitwise operations to SPIR-V operations. This is a special pattern
Value result = emulateSignedRemainder<spirv::GLSLSAbsOp>(
       op.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
       adaptor.getOperands()[0], rewriter);
   rewriter.replaceOp(op, result);
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// RemSIOpOCLPattern
+// RemSIOpCLPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult
-RemSIOpOCLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
-                                   ConversionPatternRewriter &rewriter) const {
-  Value result = emulateSignedRemainder<spirv::OCLSAbsOp>(
+RemSIOpCLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
+  Value result = emulateSignedRemainder<spirv::CLSAbsOp>(
       op.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
       adaptor.getOperands()[0], rewriter);
   rewriter.replaceOp(op, result);
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
patterns.add<
     ConstantCompositeOpPattern,
     ConstantScalarOpPattern,
     spirv::ElementwiseOpPattern<arith::AddIOp, spirv::IAddOp>,
     spirv::ElementwiseOpPattern<arith::SubIOp, spirv::ISubOp>,
     spirv::ElementwiseOpPattern<arith::MulIOp, spirv::IMulOp>,
     spirv::ElementwiseOpPattern<arith::DivUIOp, spirv::UDivOp>,
     spirv::ElementwiseOpPattern<arith::DivSIOp, spirv::SDivOp>,
     spirv::ElementwiseOpPattern<arith::RemUIOp, spirv::UModOp>,
-    RemSIOpGLSLPattern, RemSIOpOCLPattern,
+    RemSIOpGLSLPattern, RemSIOpCLPattern,
     BitwiseOpPattern<arith::AndIOp, spirv::LogicalAndOp, spirv::BitwiseAndOp>,
     BitwiseOpPattern<arith::OrIOp, spirv::LogicalOrOp, spirv::BitwiseOrOp>,
     XOrIOpLogicalPattern, XOrIOpBooleanPattern,
     spirv::ElementwiseOpPattern<arith::ShLIOp, spirv::ShiftLeftLogicalOp>,
     spirv::ElementwiseOpPattern<arith::ShRUIOp, spirv::ShiftRightLogicalOp>,
     spirv::ElementwiseOpPattern<arith::ShRSIOp, spirv::ShiftRightArithmeticOp>,
     spirv::ElementwiseOpPattern<arith::NegFOp, spirv::FNegateOp>,
     spirv::ElementwiseOpPattern<arith::AddFOp, spirv::FAddOp>,

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

patterns
            spirv::ElementwiseOpPattern<math::LogOp, spirv::GLSLLogOp>,
            spirv::ElementwiseOpPattern<math::RsqrtOp, spirv::GLSLInverseSqrtOp>,
            spirv::ElementwiseOpPattern<math::SinOp, spirv::GLSLSinOp>,
            spirv::ElementwiseOpPattern<math::SqrtOp, spirv::GLSLSqrtOp>,
            spirv::ElementwiseOpPattern<math::TanhOp, spirv::GLSLTanhOp>>(
           typeConverter, patterns.getContext());
 
   // OpenCL patterns
-  patterns.add<Log1pOpPattern<spirv::OCLLogOp>, ExpM1OpPattern<spirv::OCLExpOp>,
-               spirv::ElementwiseOpPattern<math::AbsOp, spirv::OCLFAbsOp>,
-               spirv::ElementwiseOpPattern<math::CeilOp, spirv::OCLCeilOp>,
-               spirv::ElementwiseOpPattern<math::CosOp, spirv::OCLCosOp>,
-               spirv::ElementwiseOpPattern<math::ErfOp, spirv::OCLErfOp>,
-               spirv::ElementwiseOpPattern<math::ExpOp, spirv::OCLExpOp>,
-               spirv::ElementwiseOpPattern<math::FloorOp, spirv::OCLFloorOp>,
-               spirv::ElementwiseOpPattern<math::FmaOp, spirv::OCLFmaOp>,
-               spirv::ElementwiseOpPattern<math::LogOp, spirv::OCLLogOp>,
-               spirv::ElementwiseOpPattern<math::PowFOp, spirv::OCLPowOp>,
-               spirv::ElementwiseOpPattern<math::RoundOp, spirv::OCLRoundOp>,
-               spirv::ElementwiseOpPattern<math::RsqrtOp, spirv::OCLRsqrtOp>,
-               spirv::ElementwiseOpPattern<math::SinOp, spirv::OCLSinOp>,
-               spirv::ElementwiseOpPattern<math::SqrtOp, spirv::OCLSqrtOp>,
-               spirv::ElementwiseOpPattern<math::TanhOp, spirv::OCLTanhOp>>(
+  patterns.add<Log1pOpPattern<spirv::CLLogOp>, ExpM1OpPattern<spirv::CLExpOp>,
+               spirv::ElementwiseOpPattern<math::AbsOp, spirv::CLFAbsOp>,
+               spirv::ElementwiseOpPattern<math::CeilOp, spirv::CLCeilOp>,
+               spirv::ElementwiseOpPattern<math::CosOp, spirv::CLCosOp>,
+               spirv::ElementwiseOpPattern<math::ErfOp, spirv::CLErfOp>,
+               spirv::ElementwiseOpPattern<math::ExpOp, spirv::CLExpOp>,
+               spirv::ElementwiseOpPattern<math::FloorOp, spirv::CLFloorOp>,
+               spirv::ElementwiseOpPattern<math::FmaOp, spirv::CLFmaOp>,
+               spirv::ElementwiseOpPattern<math::LogOp, spirv::CLLogOp>,
+               spirv::ElementwiseOpPattern<math::PowFOp, spirv::CLPowOp>,
+               spirv::ElementwiseOpPattern<math::RoundOp, spirv::CLRoundOp>,
+               spirv::ElementwiseOpPattern<math::RsqrtOp, spirv::CLRsqrtOp>,
+               spirv::ElementwiseOpPattern<math::SinOp, spirv::CLSinOp>,
+               spirv::ElementwiseOpPattern<math::SqrtOp, spirv::CLSqrtOp>,
+               spirv::ElementwiseOpPattern<math::TanhOp, spirv::CLTanhOp>>(
       typeConverter, patterns.getContext());
 }
 
 } // namespace mlir

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

 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Int16, Kernel], []>, #spv.resource_limits<>>
 } {
 
 // CHECK-LABEL: @scalar_srem
 // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
 func.func @scalar_srem(%lhs: i32, %rhs: i32) {
-  // CHECK: %[[LABS:.+]] = spv.OCL.s_abs %[[LHS]] : i32
-  // CHECK: %[[RABS:.+]] = spv.OCL.s_abs %[[RHS]] : i32
+  // CHECK: %[[LABS:.+]] = spv.CL.s_abs %[[LHS]] : i32
+  // CHECK: %[[RABS:.+]] = spv.CL.s_abs %[[RHS]] : i32
   // CHECK:  %[[ABS:.+]] = spv.UMod %[[LABS]], %[[RABS]] : i32
   // CHECK:  %[[POS:.+]] = spv.IEqual %[[LHS]], %[[LABS]] : i32
   // CHECK:  %[[NEG:.+]] = spv.SNegate %[[ABS]] : i32
   // CHECK:      %{{.+}} = spv.Select %[[POS]], %[[ABS]], %[[NEG]] : i1, i32
   %0 = arith.remsi %lhs, %rhs: i32
   return
 }
 
 // CHECK-LABEL: @vector_srem
 // CHECK-SAME: (%[[LHS:.+]]: vector<3xi16>, %[[RHS:.+]]: vector<3xi16>)
 func.func @vector_srem(%arg0: vector<3xi16>, %arg1: vector<3xi16>) {
-  // CHECK: %[[LABS:.+]] = spv.OCL.s_abs %[[LHS]] : vector<3xi16>
-  // CHECK: %[[RABS:.+]] = spv.OCL.s_abs %[[RHS]] : vector<3xi16>
+  // CHECK: %[[LABS:.+]] = spv.CL.s_abs %[[LHS]] : vector<3xi16>
+  // CHECK: %[[RABS:.+]] = spv.CL.s_abs %[[RHS]] : vector<3xi16>
   // CHECK:  %[[ABS:.+]] = spv.UMod %[[LABS]], %[[RABS]] : vector<3xi16>
   // CHECK:  %[[POS:.+]] = spv.IEqual %[[LHS]], %[[LABS]] : vector<3xi16>
   // CHECK:  %[[NEG:.+]] = spv.SNegate %[[ABS]] : vector<3xi16>
   // CHECK:      %{{.+}} = spv.Select %[[POS]], %[[ABS]], %[[NEG]] : vector<3xi1>, vector<3xi16>
   %0 = arith.remsi %arg0, %arg1: vector<3xi16>
   return
 }
 

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], []>, #spv.resource_limits<>> } {
 
 // CHECK-LABEL: @float32_unary_scalar
 func.func @float32_unary_scalar(%arg0: f32) {
-  // CHECK: spv.OCL.cos %{{.*}}: f32
+  // CHECK: spv.CL.cos %{{.*}}: f32
   %0 = math.cos %arg0 : f32
-  // CHECK: spv.OCL.exp %{{.*}}: f32
+  // CHECK: spv.CL.exp %{{.*}}: f32
   %1 = math.exp %arg0 : f32
-  // CHECK: %[[EXP:.+]] = spv.OCL.exp %arg0
+  // CHECK: %[[EXP:.+]] = spv.CL.exp %arg0
   // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
   // CHECK: spv.FSub %[[EXP]], %[[ONE]]
   %2 = math.expm1 %arg0 : f32
-  // CHECK: spv.OCL.log %{{.*}}: f32
+  // CHECK: spv.CL.log %{{.*}}: f32
   %3 = math.log %arg0 : f32
   // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
   // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
-  // CHECK: spv.OCL.log %[[ADDONE]]
+  // CHECK: spv.CL.log %[[ADDONE]]
   %4 = math.log1p %arg0 : f32
-  // CHECK: spv.OCL.rsqrt %{{.*}}: f32
+  // CHECK: spv.CL.rsqrt %{{.*}}: f32
   %5 = math.rsqrt %arg0 : f32
-  // CHECK: spv.OCL.sqrt %{{.*}}: f32
+  // CHECK: spv.CL.sqrt %{{.*}}: f32
   %6 = math.sqrt %arg0 : f32
-  // CHECK: spv.OCL.tanh %{{.*}}: f32
+  // CHECK: spv.CL.tanh %{{.*}}: f32
   %7 = math.tanh %arg0 : f32
-  // CHECK: spv.OCL.sin %{{.*}}: f32
+  // CHECK: spv.CL.sin %{{.*}}: f32
   %8 = math.sin %arg0 : f32
-  // CHECK: spv.OCL.fabs %{{.*}}: f32
+  // CHECK: spv.CL.fabs %{{.*}}: f32
   %9 = math.abs %arg0 : f32
-  // CHECK: spv.OCL.ceil %{{.*}}: f32
+  // CHECK: spv.CL.ceil %{{.*}}: f32
   %10 = math.ceil %arg0 : f32
-  // CHECK: spv.OCL.floor %{{.*}}: f32
+  // CHECK: spv.CL.floor %{{.*}}: f32
   %11 = math.floor %arg0 : f32
-  // CHECK: spv.OCL.erf %{{.*}}: f32
+  // CHECK: spv.CL.erf %{{.*}}: f32
   %12 = math.erf %arg0 : f32
-  // CHECK: spv.OCL.round %{{.*}}: f32
+  // CHECK: spv.CL.round %{{.*}}: f32
   %13 = math.round %arg0 : f32
   return
 }
 
 // CHECK-LABEL: @float32_unary_vector
 func.func @float32_unary_vector(%arg0: vector<3xf32>) {
-  // CHECK: spv.OCL.cos %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.cos %{{.*}}: vector<3xf32>
   %0 = math.cos %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.exp %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.exp %{{.*}}: vector<3xf32>
   %1 = math.exp %arg0 : vector<3xf32>
-  // CHECK: %[[EXP:.+]] = spv.OCL.exp %arg0
+  // CHECK: %[[EXP:.+]] = spv.CL.exp %arg0
   // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00> : vector<3xf32>
   // CHECK: spv.FSub %[[EXP]], %[[ONE]]
   %2 = math.expm1 %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.log %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.log %{{.*}}: vector<3xf32>
   %3 = math.log %arg0 : vector<3xf32>
   // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00> : vector<3xf32>
   // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
-  // CHECK: spv.OCL.log %[[ADDONE]]
+  // CHECK: spv.CL.log %[[ADDONE]]
   %4 = math.log1p %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.rsqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.rsqrt %{{.*}}: vector<3xf32>
   %5 = math.rsqrt %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.sqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.sqrt %{{.*}}: vector<3xf32>
   %6 = math.sqrt %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.tanh %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.tanh %{{.*}}: vector<3xf32>
   %7 = math.tanh %arg0 : vector<3xf32>
-  // CHECK: spv.OCL.sin %{{.*}}: vector<3xf32>
+  // CHECK: spv.CL.sin %{{.*}}: vector<3xf32>
   %8 = math.sin %arg0 : vector<3xf32>
   return
 }
 
 // CHECK-LABEL: @float32_binary_scalar
 func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
-  // CHECK: spv.OCL.pow %{{.*}}: f32
+  // CHECK: spv.CL.pow %{{.*}}: f32
   %0 = math.powf %lhs, %rhs : f32
   return
 }
 
 // CHECK-LABEL: @float32_binary_vector
 func.func @float32_binary_vector(%lhs: vector<4xf32>, %rhs: vector<4xf32>) {
-  // CHECK: spv.OCL.pow %{{.*}}: vector<4xf32>
+  // CHECK: spv.CL.pow %{{.*}}: vector<4xf32>
   %0 = math.powf %lhs, %rhs : vector<4xf32>
   return
 }
 
 // CHECK-LABEL: @float32_ternary_scalar
 func.func @float32_ternary_scalar(%a: f32, %b: f32, %c: f32) {
-  // CHECK: spv.OCL.fma %{{.*}}: f32
+  // CHECK: spv.CL.fma %{{.*}}: f32
   %0 = math.fma %a, %b, %c : f32
   return
 }
 
 // CHECK-LABEL: @float32_ternary_vector
 func.func @float32_ternary_vector(%a: vector<4xf32>, %b: vector<4xf32>,
                             %c: vector<4xf32>) {
-  // CHECK: spv.OCL.fma %{{.*}}: vector<4xf32>
+  // CHECK: spv.CL.fma %{{.*}}: vector<4xf32>
   %0 = math.fma %a, %b, %c : vector<4xf32>
   return
 }
 
 } // end module

mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir

 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
-// spv.OCL.exp
+// spv.CL.exp
 //===----------------------------------------------------------------------===//
 
 func.func @exp(%arg0 : f32) -> () {
-  // CHECK: spv.OCL.exp {{%.*}} : f32
-  %2 = spv.OCL.exp %arg0 : f32
+  // CHECK: spv.CL.exp {{%.*}} : f32
+  %2 = spv.CL.exp %arg0 : f32
   return
 }
 
 func.func @expvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.OCL.exp {{%.*}} : vector<3xf16>
-  %2 = spv.OCL.exp %arg0 : vector<3xf16>
+  // CHECK: spv.CL.exp {{%.*}} : vector<3xf16>
+  %2 = spv.CL.exp %arg0 : vector<3xf16>
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
-  %2 = spv.OCL.exp %arg0 : i32
+  %2 = spv.CL.exp %arg0 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : vector<5xf32>) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
-  %2 = spv.OCL.exp %arg0 : vector<5xf32>
+  %2 = spv.CL.exp %arg0 : vector<5xf32>
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
-  %2 = spv.OCL.exp %arg0, %arg1 : i32
+  %2 = spv.CL.exp %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
   // expected-error @+1 {{expected non-function type}}
-  %2 = spv.OCL.exp %arg0 :
+  %2 = spv.CL.exp %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.OCL.fabs
+// spv.CL.fabs
 //===----------------------------------------------------------------------===//
 
 func.func @fabs(%arg0 : f32) -> () {
-  // CHECK: spv.OCL.fabs {{%.*}} : f32
-  %2 = spv.OCL.fabs %arg0 : f32
+  // CHECK: spv.CL.fabs {{%.*}} : f32
+  %2 = spv.CL.fabs %arg0 : f32
   return
 }
 
 func.func @fabsvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.OCL.fabs {{%.*}} : vector<3xf16>
-  %2 = spv.OCL.fabs %arg0 : vector<3xf16>
+  // CHECK: spv.CL.fabs {{%.*}} : vector<3xf16>
+  %2 = spv.CL.fabs %arg0 : vector<3xf16>
   return
 }
 
 func.func @fabsf64(%arg0 : f64) -> () {
-  // CHECK: spv.OCL.fabs {{%.*}} : f64
-  %2 = spv.OCL.fabs %arg0 : f64
+  // CHECK: spv.CL.fabs {{%.*}} : f64
+  %2 = spv.CL.fabs %arg0 : f64
   return
 }
 
 // -----
 
 func.func @fabs(%arg0 : i32) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values}}
-  %2 = spv.OCL.fabs %arg0 : i32
+  %2 = spv.CL.fabs %arg0 : i32
   return
 }
 
 // -----
 
 func.func @fabs(%arg0 : vector<5xf32>) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32/64-bit float or vector of 16/32/64-bit float values of length 2/3/4}}
-  %2 = spv.OCL.fabs %arg0 : vector<5xf32>
+  %2 = spv.CL.fabs %arg0 : vector<5xf32>
   return
 }
 
 // -----
 
 func.func @fabs(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
-  %2 = spv.OCL.fabs %arg0, %arg1 : i32
+  %2 = spv.CL.fabs %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @fabs(%arg0 : i32) -> () {
   // expected-error @+1 {{expected non-function type}}
-  %2 = spv.OCL.fabs %arg0 :
+  %2 = spv.CL.fabs %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.OCL.s_abs
+// spv.CL.s_abs
 //===----------------------------------------------------------------------===//
 
 func.func @sabs(%arg0 : i32) -> () {
-  // CHECK: spv.OCL.s_abs {{%.*}} : i32
-  %2 = spv.OCL.s_abs %arg0 : i32
+  // CHECK: spv.CL.s_abs {{%.*}} : i32
+  %2 = spv.CL.s_abs %arg0 : i32
   return
 }
 
 func.func @sabsvec(%arg0 : vector<3xi16>) -> () {
-  // CHECK: spv.OCL.s_abs {{%.*}} : vector<3xi16>
-  %2 = spv.OCL.s_abs %arg0 : vector<3xi16>
+  // CHECK: spv.CL.s_abs {{%.*}} : vector<3xi16>
+  %2 = spv.CL.s_abs %arg0 : vector<3xi16>
   return
 }
 
 func.func @sabsi64(%arg0 : i64) -> () {
-  // CHECK: spv.OCL.s_abs {{%.*}} : i64
-  %2 = spv.OCL.s_abs %arg0 : i64
+  // CHECK: spv.CL.s_abs {{%.*}} : i64
+  %2 = spv.CL.s_abs %arg0 : i64
   return
 }
 
 func.func @sabsi8(%arg0 : i8) -> () {
-  // CHECK: spv.OCL.s_abs {{%.*}} : i8
-  %2 = spv.OCL.s_abs %arg0 : i8
+  // CHECK: spv.CL.s_abs {{%.*}} : i8
+  %2 = spv.CL.s_abs %arg0 : i8
   return
 }
 
 // -----
 
 func.func @sabs(%arg0 : f32) -> () {
   // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values}}
-  %2 = spv.OCL.s_abs %arg0 : f32
+  %2 = spv.CL.s_abs %arg0 : f32
   return
 }
 
 // -----
 
 func.func @sabs(%arg0 : vector<5xi32>) -> () {
   // expected-error @+1 {{op operand #0 must be 8/16/32/64-bit integer or vector of 8/16/32/64-bit integer values of length 2/3/4}}
-  %2 = spv.OCL.s_abs %arg0 : vector<5xi32>
+  %2 = spv.CL.s_abs %arg0 : vector<5xi32>
   return
 }
 
 // -----
 
 func.func @sabs(%arg0 : i32, %arg1 : i32) -> () {
   // expected-error @+1 {{expected ':'}}
-  %2 = spv.OCL.s_abs %arg0, %arg1 : i32
+  %2 = spv.CL.s_abs %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @sabs(%arg0 : i32) -> () {
   // expected-error @+1 {{expected non-function type}}
-  %2 = spv.OCL.s_abs %arg0 :
+  %2 = spv.CL.s_abs %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.OCL.fma
+// spv.CL.fma
 //===----------------------------------------------------------------------===//
 
 func.func @fma(%a : f32, %b : f32, %c : f32) -> () {
-  // CHECK: spv.OCL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-  %2 = spv.OCL.fma %a, %b, %c : f32
+  // CHECK: spv.CL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+  %2 = spv.CL.fma %a, %b, %c : f32
   return
 }
 
 // -----
 
 func.func @fma(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () {
-  // CHECK: spv.OCL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
-  %2 = spv.OCL.fma %a, %b, %c : vector<3xf32>
+  // CHECK: spv.CL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
+  %2 = spv.CL.fma %a, %b, %c : vector<3xf32>
   return
 }

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
-    // CHECK: {{%.*}} = spv.OCL.erf {{%.*}} : f32
-    %10 = spv.OCL.erf %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.exp {{%.*}} : f32
+    %0 = spv.CL.exp %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.fabs {{%.*}} : f32
+    %1 = spv.CL.fabs %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.sin {{%.*}} : f32
+    %2 = spv.CL.sin %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.cos {{%.*}} : f32
+    %3 = spv.CL.cos %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.log {{%.*}} : f32
+    %4 = spv.CL.log %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.sqrt {{%.*}} : f32
+    %5 = spv.CL.sqrt %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.ceil {{%.*}} : f32
+    %6 = spv.CL.ceil %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.floor {{%.*}} : f32
+    %7 = spv.CL.floor %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.pow {{%.*}}, {{%.*}} : f32
+    %8 = spv.CL.pow %arg0, %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.rsqrt {{%.*}} : f32
+    %9 = spv.CL.rsqrt %arg0 : f32
+    // CHECK: {{%.*}} = spv.CL.erf {{%.*}} : f32
+    %10 = spv.CL.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
+    // CHECK: {{%.*}} = spv.CL.s_abs {{%.*}} : i32
+    %0 = spv.CL.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>
+    // CHECK: {{%.*}} = spv.CL.fabs {{%.*}} : vector<16xf32>
+    %0 = spv.CL.fabs %arg0 : vector<16xf32>
     spv.Return
   }
 
   spv.func @fma(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
-    // CHECK: spv.OCL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-    %13 = spv.OCL.fma %arg0, %arg1, %arg2 : f32
+    // CHECK: spv.CL.fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+    %13 = spv.CL.fma %arg0, %arg1, %arg2 : f32
     spv.Return
   }
 }

mlir/utils/spirv/gen_spirv_dialect.py

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
 # 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
 
 # Script for updating SPIR-V dialect by scraping information from SPIR-V
 # HTML and JSON specs from the Internet.
 #
 # For example, to define the enum attribute for SPIR-V memory model:
 #
-# ./gen_spirv_dialect.py --base_td_path /path/to/SPIRVBase.td \
+# ./gen_spirv_dialect.py --base-td-path /path/to/SPIRVBase.td \
 #                        --new-enum MemoryModel
 #
 # The 'operand_kinds' dict of spirv.core.grammar.json contains all supported
 # SPIR-V enum classes.
 
 import itertools
 import re
 import requests
 import textwrap
 import yaml
 
 SPIRV_HTML_SPEC_URL = 'https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html'
 SPIRV_JSON_SPEC_URL = 'https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/spirv.core.grammar.json'
 
-SPIRV_OCL_EXT_HTML_SPEC_URL = 'https://www.khronos.org/registry/SPIR-V/specs/unified1/OpenCL.ExtendedInstructionSet.100.html'
-SPIRV_OCL_EXT_JSON_SPEC_URL = 'https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/extinst.opencl.std.100.grammar.json'
+SPIRV_CL_EXT_HTML_SPEC_URL = 'https://www.khronos.org/registry/SPIR-V/specs/unified1/OpenCL.ExtendedInstructionSet.100.html'
+SPIRV_CL_EXT_JSON_SPEC_URL = 'https://raw.githubusercontent.com/KhronosGroup/SPIRV-Headers/master/include/spirv/unified1/extinst.opencl.std.100.grammar.json'
 
 AUTOGEN_OP_DEF_SEPARATOR = '\n// -----\n\n'
 AUTOGEN_ENUM_SECTION_MARKER = 'enum section. Generated from SPIR-V spec; DO NOT MODIFY!'
 AUTOGEN_OPCODE_SECTION_MARKER = (
     'opcode section. Generated from SPIR-V spec; DO NOT MODIFY!')
 
 def get_spirv_doc_from_html_spec(url, settings):
   """Extracts instruction documentation from SPIR-V HTML spec.
 
   Returns:
     - A dict mapping from instruction opcode to documentation.
   """
   if url is None:
     url = SPIRV_HTML_SPEC_URL
 
   response = requests.get(url)
   spec = response.content
 
   from bs4 import BeautifulSoup
   spirv = BeautifulSoup(spec, 'html.parser')
 
   doc = {}
 
-  if settings.gen_ocl_ops:
+  if settings.gen_cl_ops:
     section_anchor = spirv.find('h2', {'id': '_binary_form'})
     for section in section_anchor.parent.find_all('div', {'class': 'sect2'}):
       for table in section.find_all('table'):
         inst_html = table.tbody.tr.td
         opname = inst_html.a['id']
         # Ignore the first line, which is just the opname.
         doc[opname] = inst_html.text.split('\n', 1)[1].strip()
   else:
Arguments:
     - existing_info: a dict containing potential manually specified sections for
       this instruction
     - capability_mapping: mapping from duplicated capability symbols to the
                    canonicalized symbol chosen for SPIRVBase.td
 
   Returns:
     - A string containing the TableGen op definition
   """
-  if settings.gen_ocl_ops:
+  if settings.gen_cl_ops:
     fmt_str = ('def SPV_{opname}Op : '
                'SPV_{inst_category}<"{opname_src}", {opcode}, <<Insert result type>> > '
                '{{\n  let summary = {summary};\n\n  let description = '
                '[{{\n{description}}}];{availability}\n')
   else:
     fmt_str = ('def SPV_{opname_src}Op : '
                'SPV_{inst_category}<"{opname_src}"{category_args}[{traits}]> '
                '{{\n  let summary = {summary};\n\n  let description = '
for op in ops:
     opname = info_dict['opname']
     name_op_map[opname] = op
     op_info_dict[opname] = info_dict
     filter_list.append(opname)
   filter_list = sorted(list(set(filter_list)))
 
   op_defs = []
 
-  if settings.gen_ocl_ops:
-    fix_opname = lambda src: src.replace('OCL','').lower()
+  if settings.gen_cl_ops:
+    fix_opname = lambda src: src.replace('CL','').lower()
   else:
     fix_opname = lambda src: src
 
   for opname in filter_list:
     # Find the grammar spec for this op
     try:
       fixed_opname = fix_opname(opname)
       instruction = next(
if __name__ == '__main__':
   cli_parser.add_argument(
       '--inst-category',
       dest='inst_category',
       type=str,
       default='Op',
       help='SPIR-V instruction category used for choosing '\
            'the TableGen base class to define this op')
   cli_parser.add_argument(
-      '--gen-ocl-ops',
-      dest='gen_ocl_ops',
+      '--gen-cl-ops',
+      dest='gen_cl_ops',
       help='Generate OpenCL Extended Instruction Set op',
       action='store_true')
-  cli_parser.set_defaults(gen_ocl_ops=False)
+  cli_parser.set_defaults(gen_cl_ops=False)
   cli_parser.add_argument('--gen-inst-coverage', dest='gen_inst_coverage', action='store_true')
   cli_parser.set_defaults(gen_inst_coverage=False)
 
   args = cli_parser.parse_args()
 
-  if args.gen_ocl_ops:
-    ext_html_url = SPIRV_OCL_EXT_HTML_SPEC_URL
-    ext_json_url = SPIRV_OCL_EXT_JSON_SPEC_URL
+  if args.gen_cl_ops:
+    ext_html_url = SPIRV_CL_EXT_HTML_SPEC_URL
+    ext_json_url = SPIRV_CL_EXT_JSON_SPEC_URL
   else:
     ext_html_url = None
     ext_json_url = None
 
   operand_kinds, instructions = get_spirv_grammar_from_json_spec(ext_json_url)
 
   # Define new enum attr
   if args.new_enum is not None: