diff --git a/mlir/docs/SPIRVToLLVMDialectConversion.md b/mlir/docs/SPIRVToLLVMDialectConversion.md
--- a/mlir/docs/SPIRVToLLVMDialectConversion.md
+++ b/mlir/docs/SPIRVToLLVMDialectConversion.md
@@ -622,7 +622,7 @@
 *   All atomic ops
 *   All group ops
 *   All matrix ops
-*   All OCL ops
+*   All CL ops
 
 As well as:
 
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
rename from mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td
rename to mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOCLOps.td
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVCLOps.td
@@ -1,4 +1,4 @@
-//===- 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.
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#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"
 
@@ -20,8 +20,8 @@
 //===----------------------------------------------------------------------===//
 
 // 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>,
@@ -32,9 +32,9 @@
 }
 
 // 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
@@ -51,15 +51,15 @@
 
 // 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,
@@ -75,17 +75,17 @@
 
 // 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,
@@ -102,9 +102,9 @@
 
 // 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)";
 }
@@ -113,7 +113,7 @@
 
 // -----
 
-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.
@@ -131,22 +131,22 @@
     ```
     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 = [{
@@ -161,22 +161,22 @@
     ```
     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.
   }];
@@ -193,22 +193,22 @@
     ```
     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 = [{
@@ -224,21 +224,21 @@
     ```
     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 = [{
@@ -254,21 +254,21 @@
     ```
     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.
@@ -286,22 +286,22 @@
     ```
     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
@@ -319,20 +319,20 @@
     <!-- 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 = [{
@@ -347,22 +347,22 @@
     ```
     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 = [{
@@ -379,21 +379,21 @@
     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.
@@ -411,21 +411,21 @@
     ```
     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 = [{
@@ -440,22 +440,22 @@
     ```
     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 = [{
@@ -470,22 +470,22 @@
     ```
     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 = [{
@@ -500,22 +500,22 @@
     ```
     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 = [{
@@ -530,22 +530,22 @@
     ```
     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 = [{
@@ -561,16 +561,16 @@
     ```
     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
diff --git a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.td b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.td
--- a/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.td
+++ b/mlir/include/mlir/Dialect/SPIRV/IR/SPIRVOps.td
@@ -38,7 +38,7 @@
 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"
 
diff --git a/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp b/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp
--- a/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp
+++ b/mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp
@@ -60,7 +60,7 @@
 };
 
 /// 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
@@ -487,13 +487,13 @@
 }
 
 //===----------------------------------------------------------------------===//
-// 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,
+                                  ConversionPatternRewriter &rewriter) const {
+  Value result = emulateSignedRemainder<spirv::CLSAbsOp>(
       op.getLoc(), adaptor.getOperands()[0], adaptor.getOperands()[1],
       adaptor.getOperands()[0], rewriter);
   rewriter.replaceOp(op, result);
@@ -862,7 +862,7 @@
     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,
diff --git a/mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp b/mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp
--- a/mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp
+++ b/mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp
@@ -301,21 +301,21 @@
           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());
 }
 
diff --git a/mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir b/mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir
--- a/mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir
+++ b/mlir/test/Conversion/ArithmeticToSPIRV/arithmetic-to-spirv.mlir
@@ -952,8 +952,8 @@
 // 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
@@ -965,8 +965,8 @@
 // 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>
diff --git a/mlir/test/Conversion/MathToSPIRV/math-to-opencl-spirv.mlir b/mlir/test/Conversion/MathToSPIRV/math-to-opencl-spirv.mlir
--- a/mlir/test/Conversion/MathToSPIRV/math-to-opencl-spirv.mlir
+++ b/mlir/test/Conversion/MathToSPIRV/math-to-opencl-spirv.mlir
@@ -4,85 +4,85 @@
 
 // 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
 }
@@ -90,7 +90,7 @@
 // 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
 }
diff --git a/mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir b/mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir
--- a/mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir
+++ b/mlir/test/Dialect/SPIRV/IR/ocl-ops.mlir
@@ -1,18 +1,18 @@
 // 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
 }
 
@@ -20,7 +20,7 @@
 
 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
 }
 
@@ -28,7 +28,7 @@
 
 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
 }
 
@@ -36,7 +36,7 @@
 
 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
 }
 
@@ -44,31 +44,31 @@
 
 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
 }
 
@@ -76,7 +76,7 @@
 
 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
 }
 
@@ -84,7 +84,7 @@
 
 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
 }
 
@@ -92,7 +92,7 @@
 
 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
 }
 
@@ -100,37 +100,37 @@
 
 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
 }
 
@@ -138,7 +138,7 @@
 
 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
 }
 
@@ -146,7 +146,7 @@
 
 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
 }
 
@@ -154,7 +154,7 @@
 
 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
 }
 
@@ -162,26 +162,26 @@
 
 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
 }
diff --git a/mlir/test/Target/SPIRV/ocl-ops.mlir b/mlir/test/Target/SPIRV/ocl-ops.mlir
--- a/mlir/test/Target/SPIRV/ocl-ops.mlir
+++ b/mlir/test/Target/SPIRV/ocl-ops.mlir
@@ -2,46 +2,46 @@
 
 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
   }
 }
diff --git a/mlir/utils/spirv/gen_spirv_dialect.py b/mlir/utils/spirv/gen_spirv_dialect.py
--- a/mlir/utils/spirv/gen_spirv_dialect.py
+++ b/mlir/utils/spirv/gen_spirv_dialect.py
@@ -10,7 +10,7 @@
 #
 # 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
@@ -25,8 +25,8 @@
 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!'
@@ -50,7 +50,7 @@
 
   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'):
@@ -703,7 +703,7 @@
   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 = '
@@ -959,8 +959,8 @@
 
   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
 
@@ -1035,19 +1035,19 @@
       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