[mlir][spirv] Rename spv.GLSL ops to spv.GL. NFC.

[kuhar]

Summary

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

[kuhar]

Fix a markdown table

[kuhar]

Fix tablegen formatting

[antiagainst]

Awesome!

mlir/docs/Dialects/SPIR-V.md

 
 ## Conventions
 
 The SPIR-V dialect adopts the following conventions for IR:
 
 *   The prefix for all SPIR-V types and operations are `spv.`.
 *   All instructions in an extended instruction set are further qualified with
     the extended instruction set's prefix. For example, all operations in the
-    GLSL extended instruction set have the prefix of `spv.GLSL.`.
+    GLSL extended instruction set have the prefix of `spv.GL.`.
 *   Ops that directly mirror instructions in the specification have `CamelCase`
     names that are the same as the instruction opnames (without the `Op`
     prefix). For example, `spv.FMul` is a direct mirror of `OpFMul` in the
     specification. Such an op will be serialized into and deserialized from one
     SPIR-V instruction.
 *   Ops with `snake_case` names are those that have different representation
     from corresponding instructions (or concepts) in the specification. These
     ops are mostly for defining the SPIR-V structure. For example, `spv.module`

 
 %1 = OpExtInst %f32 %glsl 28 %cst
 %2 = OpExtInst %f32 %glsl 31 %cst
 ```
 
 we can have
 
 ```mlir
-%1 = "spv.GLSL.Log"(%cst) : (f32) -> (f32)
-%2 = "spv.GLSL.Sqrt"(%cst) : (f32) -> (f32)
+%1 = "spv.GL.Log"(%cst) : (f32) -> (f32)
+%2 = "spv.GL.Sqrt"(%cst) : (f32) -> (f32)
 ```
 
 ## Control Flow
 
 SPIR-V binary format uses merge instructions (`OpSelectionMerge` and
 `OpLoopMerge`) to declare structured control flow. They explicitly declare a
 header block before the control flow diverges and a merge block where control
 flow subsequently converges. These blocks delimit constructs that must nest, and

mlir/docs/SPIRVToLLVMDialectConversion.md

 *   All CL ops
 
 As well as:
 
 *   spv.CompositeConstruct
 *   spv.ControlBarrier
 *   spv.CopyMemory
 *   spv.FMod
-*   spv.GLSL.Acos
-*   spv.GLSL.Asin
-*   spv.GLSL.Atan
-*   spv.GLSL.Cosh
-*   spv.GLSL.FSign
-*   spv.GLSL.SAbs
-*   spv.GLSL.Sinh
-*   spv.GLSL.SSign
+*   spv.GL.Acos
+*   spv.GL.Asin
+*   spv.GL.Atan
+*   spv.GL.Cosh
+*   spv.GL.FSign
+*   spv.GL.SAbs
+*   spv.GL.Sinh
+*   spv.GL.SSign
 *   spv.MemoryBarrier
 *   spv.mlir.referenceof
 *   spv.SMod
 *   spv.SpecConstant
 *   spv.Unreachable
 *   spv.VectorExtractDynamic
 
 ## Control flow conversion

 
 This section describes how SPIR-V ops from GLSL extended instructions set are
 mapped to LLVM Dialect.
 
 ### Direct conversions
 
 SPIR-V Dialect op | LLVM Dialect op
 :---------------: | :----------------:
-`spv.GLSL.Ceil`   | `llvm.intr.ceil`
-`spv.GLSL.Cos`    | `llvm.intr.cos`
-`spv.GLSL.Exp`    | `llvm.intr.exp`
-`spv.GLSL.FAbs`   | `llvm.intr.fabs`
-`spv.GLSL.Floor`  | `llvm.intr.floor`
-`spv.GLSL.FMax`   | `llvm.intr.maxnum`
-`spv.GLSL.FMin`   | `llvm.intr.minnum`
-`spv.GLSL.Log`    | `llvm.intr.log`
-`spv.GLSL.Sin`    | `llvm.intr.sin`
-`spv.GLSL.Sqrt`   | `llvm.intr.sqrt`
-`spv.GLSL.SMax`   | `llvm.intr.smax`
-`spv.GLSL.SMin`   | `llvm.intr.smin`
+`spv.GL.Ceil`     | `llvm.intr.ceil`
+`spv.GL.Cos`      | `llvm.intr.cos`
+`spv.GL.Exp`      | `llvm.intr.exp`
+`spv.GL.FAbs`     | `llvm.intr.fabs`
+`spv.GL.Floor`    | `llvm.intr.floor`
+`spv.GL.FMax`     | `llvm.intr.maxnum`
+`spv.GL.FMin`     | `llvm.intr.minnum`
+`spv.GL.Log`      | `llvm.intr.log`
+`spv.GL.Sin`      | `llvm.intr.sin`
+`spv.GL.Sqrt`     | `llvm.intr.sqrt`
+`spv.GL.SMax`     | `llvm.intr.smax`
+`spv.GL.SMin`     | `llvm.intr.smin`
 
 ### Special cases
 
 `spv.InverseSqrt` is mapped to:
 
 ```mlir
                                            %one  = llvm.mlir.constant(1.0 : f32) : f32
 %res = spv.InverseSqrt %arg : f32    =>    %sqrt = "llvm.intr.sqrt"(%arg) : (f32) -> f32

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

     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_MatrixStride                       : I32EnumAttrCase<"MatrixStride", 7> {
   list<Availability> availability = [
     Capability<[SPV_C_Matrix]>
   ];
 }
-def SPV_D_GLSLShared                         : I32EnumAttrCase<"GLSLShared", 8> {
+def SPV_D_GLShared                           : I32EnumAttrCase<"GLShared", 8> {
   list<Availability> availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
-def SPV_D_GLSLPacked                         : I32EnumAttrCase<"GLSLPacked", 9> {
+def SPV_D_GLPacked                           : I32EnumAttrCase<"GLPacked", 9> {
   list<Availability> availability = [
     Capability<[SPV_C_Shader]>
   ];
 }
 def SPV_D_CPacked                            : I32EnumAttrCase<"CPacked", 10> {
   list<Availability> availability = [
     Capability<[SPV_C_Kernel]>
   ];

     Capability<[SPV_C_VectorComputeINTEL]>
   ];
 }
 
 def SPV_DecorationAttr :
     SPV_I32EnumAttr<"Decoration", "valid SPIR-V Decoration", [
       SPV_D_RelaxedPrecision, SPV_D_SpecId, SPV_D_Block, SPV_D_BufferBlock,
       SPV_D_RowMajor, SPV_D_ColMajor, SPV_D_ArrayStride, SPV_D_MatrixStride,
-      SPV_D_GLSLShared, SPV_D_GLSLPacked, SPV_D_CPacked, SPV_D_BuiltIn,
+      SPV_D_GLShared, SPV_D_GLPacked, SPV_D_CPacked, SPV_D_BuiltIn,
       SPV_D_NoPerspective, SPV_D_Flat, SPV_D_Patch, SPV_D_Centroid, SPV_D_Sample,
       SPV_D_Invariant, SPV_D_Restrict, SPV_D_Aliased, SPV_D_Volatile, SPV_D_Constant,
       SPV_D_Coherent, SPV_D_NonWritable, SPV_D_NonReadable, SPV_D_Uniform,
       SPV_D_UniformId, SPV_D_SaturatedConversion, SPV_D_Stream, SPV_D_Location,
       SPV_D_Component, SPV_D_Index, SPV_D_Binding, SPV_D_DescriptorSet, SPV_D_Offset,
       SPV_D_XfbBuffer, SPV_D_XfbStride, SPV_D_FuncParamAttr, SPV_D_FPRoundingMode,
       SPV_D_FPFastMathMode, SPV_D_LinkageAttributes, SPV_D_NoContraction,
       SPV_D_InputAttachmentIndex, SPV_D_Alignment, SPV_D_MaxByteOffset,

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h

-//===- SPIRVGLSLCanonicalization.h - GLSL-specific patterns -----*- C++ -*-===//
+//===- SPIRVGLCanonicalization.h - GLSL-specific patterns -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares a function to register SPIR-V GLSL-specific
 // canonicalization patterns.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_IR_SPIRVGLSLCANONICALIZATION_H_
-#define MLIR_DIALECT_SPIRV_IR_SPIRVGLSLCANONICALIZATION_H_
+#ifndef MLIR_DIALECT_SPIRV_IR_SPIRVGLCANONICALIZATION_H_
+#define MLIR_DIALECT_SPIRV_IR_SPIRVGLCANONICALIZATION_H_
 
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/PatternMatch.h"
 
 //===----------------------------------------------------------------------===//
 // GLSL canonicalization patterns
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 namespace spirv {
-/// Populates patterns to run canoncalization that involves GLSL ops.
+/// Populates patterns to run canoncalization that involves GL ops.
 ///
-/// These patterns cannot be run in default canonicalization because GLSL ops
+/// These patterns cannot be run in default canonicalization because GL ops
 /// aren't always available. So they should be involed specifically when needed.
-void populateSPIRVGLSLCanonicalizationPatterns(RewritePatternSet &results);
+void populateSPIRVGLCanonicalizationPatterns(RewritePatternSet &results);
 } // namespace spirv
 } // namespace mlir
 
-#endif // MLIR_DIALECT_SPIRV_IR_SPIRVGLSLCANONICALIZATION_H_
+#endif // MLIR_DIALECT_SPIRV_IR_SPIRVGLCANONICALIZATION_H_

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

-//===- SPIRVGLSLOps.td - GLSL extended insts spec file -----*- tablegen -*-===//
+//===- SPIRVGLOps.td - GLSL 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 GLSL extension ops.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MLIR_DIALECT_SPIRV_IR_GLSL_OPS
-#define MLIR_DIALECT_SPIRV_IR_GLSL_OPS
+#ifndef MLIR_DIALECT_SPIRV_IR_GL_OPS
+#define MLIR_DIALECT_SPIRV_IR_GL_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // SPIR-V GLSL 4.50 opcode specification.
 //===----------------------------------------------------------------------===//
 
-// Base class for all GLSL ops.
-class SPV_GLSLOp<string mnemonic, int opcode, list<Trait> traits = []> :
-  SPV_ExtInstOp<mnemonic, "GLSL", "GLSL.std.450", opcode, traits> {
+// Base class for all GL ops.
+class SPV_GLOp<string mnemonic, int opcode, list<Trait> traits = []> :
+  SPV_ExtInstOp<mnemonic, "GL", "GLSL.std.450", opcode, traits> {
 
   let availability = [
     MinVersion<SPV_V_1_0>,
     MaxVersion<SPV_V_1_5>,
     Extension<[]>,
     Capability<[SPV_C_Shader]>
   ];
 }
 
-// Base class for GLSL unary ops.
-class SPV_GLSLUnaryOp<string mnemonic, int opcode, Type resultType,
+// Base class for GL unary ops.
+class SPV_GLUnaryOp<string mnemonic, int opcode, Type resultType,
                       Type operandType, list<Trait> traits = []> :
-  SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_GLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<operandType>:$operand
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<resultType>:$result
   );
 
   let hasVerifier = 0;
 }
 
-// Base class for GLSL Unary arithmetic ops where return type matches
+// Base class for GL Unary arithmetic ops where return type matches
 // the operand type.
-class SPV_GLSLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
+class SPV_GLUnaryArithmeticOp<string mnemonic, int opcode, Type type,
                                 list<Trait> traits = []> :
-  SPV_GLSLUnaryOp<mnemonic, opcode, type, type,
+  SPV_GLUnaryOp<mnemonic, opcode, type, type,
                   traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "$operand `:` type($operand) attr-dict";
 }
 
-// Base class for GLSL binary ops.
-class SPV_GLSLBinaryOp<string mnemonic, int opcode, Type resultType,
+// Base class for GL binary ops.
+class SPV_GLBinaryOp<string mnemonic, int opcode, Type resultType,
                         Type operandType, list<Trait> traits = []> :
-  SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_GLOp<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 GLSL Binary arithmetic ops where operand types and
+// Base class for GL Binary arithmetic ops where operand types and
 // return type matches.
-class SPV_GLSLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
+class SPV_GLBinaryArithmeticOp<string mnemonic, int opcode, Type type,
                                  list<Trait> traits = []> :
-  SPV_GLSLBinaryOp<mnemonic, opcode, type, type,
+  SPV_GLBinaryOp<mnemonic, opcode, type, type,
                    traits # [SameOperandsAndResultType]> {
   let assemblyFormat = "operands attr-dict `:` type($result)";
 }
 
-// Base class for GLSL ternary ops.
-class SPV_GLSLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
+// Base class for GL ternary ops.
+class SPV_GLTernaryArithmeticOp<string mnemonic, int opcode, Type type,
                         list<Trait> traits = []> :
-  SPV_GLSLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
+  SPV_GLOp<mnemonic, opcode, !listconcat([NoSideEffect], traits)> {
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<type>:$x,
     SPV_ScalarOrVectorOf<type>:$y,
     SPV_ScalarOrVectorOf<type>:$z
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<type>:$result
   );
 
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 0;
 }
 
 // -----
 
-def SPV_GLSLFAbsOp : SPV_GLSLUnaryArithmeticOp<"FAbs", 4, SPV_Float> {
+def SPV_GLFAbsOp : SPV_GLUnaryArithmeticOp<"FAbs", 4, SPV_Float> {
   let summary = "Absolute value of operand";
 
   let description = [{
     Result is x if x >= 0; otherwise result is -x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    abs-op ::= ssa-id `=` `spv.GLSL.FAbs` ssa-use `:`
+    abs-op ::= ssa-id `=` `spv.GL.FAbs` ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FAbs %0 : f32
-    %3 = spv.GLSL.FAbs %1 : vector<3xf16>
+    %2 = spv.GL.FAbs %0 : f32
+    %3 = spv.GL.FAbs %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSAbsOp : SPV_GLSLUnaryArithmeticOp<"SAbs", 5, SPV_Integer> {
+def SPV_GLSAbsOp : SPV_GLUnaryArithmeticOp<"SAbs", 5, SPV_Integer> {
   let summary = "Absolute value of operand";
 
   let description = [{
     Result is x if x ≥ 0; otherwise result is -x, where x is interpreted as a
     signed integer.
 
     Result Type and the type of x must both be integer scalar or integer vector
     types. Result Type and operand types must have the same number of components
     with the same component width. Results are computed per component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    abs-op ::= ssa-id `=` `spv.GLSL.SAbs` ssa-use `:`
+    abs-op ::= ssa-id `=` `spv.GL.SAbs` ssa-use `:`
                integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.SAbs %0 : i32
-    %3 = spv.GLSL.SAbs %1 : vector<3xi16>
+    %2 = spv.GL.SAbs %0 : i32
+    %3 = spv.GL.SAbs %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLCeilOp : SPV_GLSLUnaryArithmeticOp<"Ceil", 9, SPV_Float> {
+def SPV_GLCeilOp : SPV_GLUnaryArithmeticOp<"Ceil", 9, SPV_Float> {
   let summary = "Rounds up to the next whole number";
 
   let description = [{
     Result is the value equal to the nearest whole number that is greater than
     or equal to x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    ceil-op ::= ssa-id `=` `spv.GLSL.Ceil` ssa-use `:`
+    ceil-op ::= ssa-id `=` `spv.GL.Ceil` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Ceil %0 : f32
-    %3 = spv.GLSL.Ceil %1 : vector<3xf16>
+    %2 = spv.GL.Ceil %0 : f32
+    %3 = spv.GL.Ceil %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLCosOp : SPV_GLSLUnaryArithmeticOp<"Cos", 14, SPV_Float16or32> {
+def SPV_GLCosOp : SPV_GLUnaryArithmeticOp<"Cos", 14, SPV_Float16or32> {
   let summary = "Cosine of operand in radians";
 
   let description = [{
     The standard trigonometric cosine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    cos-op ::= ssa-id `=` `spv.GLSL.Cos` ssa-use `:`
+    cos-op ::= ssa-id `=` `spv.GL.Cos` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Cos %0 : f32
-    %3 = spv.GLSL.Cos %1 : vector<3xf16>
+    %2 = spv.GL.Cos %0 : f32
+    %3 = spv.GL.Cos %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSinOp : SPV_GLSLUnaryArithmeticOp<"Sin", 13, SPV_Float16or32> {
+def SPV_GLSinOp : SPV_GLUnaryArithmeticOp<"Sin", 13, SPV_Float16or32> {
   let summary = "Sine of operand in radians";
 
   let description = [{
     The standard trigonometric sine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    sin-op ::= ssa-id `=` `spv.GLSL.Sin` ssa-use `:`
+    sin-op ::= ssa-id `=` `spv.GL.Sin` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Sin %0 : f32
-    %3 = spv.GLSL.Sin %1 : vector<3xf16>
+    %2 = spv.GL.Sin %0 : f32
+    %3 = spv.GL.Sin %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLTanOp : SPV_GLSLUnaryArithmeticOp<"Tan", 15, SPV_Float16or32> {
+def SPV_GLTanOp : SPV_GLUnaryArithmeticOp<"Tan", 15, SPV_Float16or32> {
   let summary = "Tangent of operand in radians";
 
   let description = [{
     The standard trigonometric tangent of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    tan-op ::= ssa-id `=` `spv.GLSL.Tan` ssa-use `:`
+    tan-op ::= ssa-id `=` `spv.GL.Tan` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Tan %0 : f32
-    %3 = spv.GLSL.Tan %1 : vector<3xf16>
+    %2 = spv.GL.Tan %0 : f32
+    %3 = spv.GL.Tan %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLAsinOp : SPV_GLSLUnaryArithmeticOp<"Asin", 16, SPV_Float16or32> {
+def SPV_GLAsinOp : SPV_GLUnaryArithmeticOp<"Asin", 16, SPV_Float16or32> {
   let summary = "Arc Sine of operand in radians";
 
   let description = [{
     The standard trigonometric arc sine of x radians.
 
     Result is an angle, in radians, whose sine is x. The range of result values
     is [-π / 2, π / 2]. Result is undefined if abs x > 1.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
     <!-- 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 `>`
-    asin-op ::= ssa-id `=` `spv.GLSL.Asin` ssa-use `:`
+    asin-op ::= ssa-id `=` `spv.GL.Asin` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Asin %0 : f32
-    %3 = spv.GLSL.Asin %1 : vector<3xf16>
+    %2 = spv.GL.Asin %0 : f32
+    %3 = spv.GL.Asin %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLAcosOp : SPV_GLSLUnaryArithmeticOp<"Acos", 17, SPV_Float16or32> {
+def SPV_GLAcosOp : SPV_GLUnaryArithmeticOp<"Acos", 17, SPV_Float16or32> {
   let summary = "Arc Cosine of operand in radians";
 
   let description = [{
     The standard trigonometric arc cosine of x radians.
 
     Result is an angle, in radians, whose cosine is x. The range of result
     values is [0, π]. Result is undefined if abs x > 1.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
     <!-- 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 `>`
-    acos-op ::= ssa-id `=` `spv.GLSL.Acos` ssa-use `:`
+    acos-op ::= ssa-id `=` `spv.GL.Acos` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Acos %0 : f32
-    %3 = spv.GLSL.Acos %1 : vector<3xf16>
+    %2 = spv.GL.Acos %0 : f32
+    %3 = spv.GL.Acos %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLAtanOp : SPV_GLSLUnaryArithmeticOp<"Atan", 18, SPV_Float16or32> {
+def SPV_GLAtanOp : SPV_GLUnaryArithmeticOp<"Atan", 18, SPV_Float16or32> {
   let summary = "Arc Tangent of operand in radians";
 
   let description = [{
     The standard trigonometric arc tangent of x radians.
 
     Result is an angle, in radians, whose tangent is y_over_x. The range of
     result values is [-π / 2, π / 2].
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
     <!-- 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 `>`
-    atan-op ::= ssa-id `=` `spv.GLSL.Atan` ssa-use `:`
+    atan-op ::= ssa-id `=` `spv.GL.Atan` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Atan %0 : f32
-    %3 = spv.GLSL.Atan %1 : vector<3xf16>
+    %2 = spv.GL.Atan %0 : f32
+    %3 = spv.GL.Atan %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLExpOp : SPV_GLSLUnaryArithmeticOp<"Exp", 27, SPV_Float16or32> {
+def SPV_GLExpOp : SPV_GLUnaryArithmeticOp<"Exp", 27, SPV_Float16or32> {
   let summary = "Exponentiation of Operand 1";
 
   let description = [{
     Result is the natural exponentiation of x; e^x.
 
     The operand x must be a scalar or vector whose component type is
     16-bit or 32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are
     computed per component.";
 
     <!-- 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 `>`
-    exp-op ::= ssa-id `=` `spv.GLSL.Exp` ssa-use `:`
+    exp-op ::= ssa-id `=` `spv.GL.Exp` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Exp %0 : f32
-    %3 = spv.GLSL.Exp %1 : vector<3xf16>
+    %2 = spv.GL.Exp %0 : f32
+    %3 = spv.GL.Exp %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFloorOp : SPV_GLSLUnaryArithmeticOp<"Floor", 8, SPV_Float> {
+def SPV_GLFloorOp : SPV_GLUnaryArithmeticOp<"Floor", 8, SPV_Float> {
   let summary = "Rounds down to the next whole number";
 
   let description = [{
     Result is the value equal to the nearest whole number that is less than or
     equal to x.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    floor-op ::= ssa-id `=` `spv.GLSL.Floor` ssa-use `:`
+    floor-op ::= ssa-id `=` `spv.GL.Floor` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Floor %0 : f32
-    %3 = spv.GLSL.Floor %1 : vector<3xf16>
+    %2 = spv.GL.Floor %0 : f32
+    %3 = spv.GL.Floor %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLRoundOp: SPV_GLSLUnaryArithmeticOp<"Round", 1, SPV_Float> {
+def SPV_GLRoundOp: SPV_GLUnaryArithmeticOp<"Round", 1, SPV_Float> {
   let summary = "Rounds to the whole number";
 
   let description = [{
     Result is the value equal to the nearest whole number.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    floor-op ::= ssa-id `=` `spv.GLSL.Round` ssa-use `:`
+    floor-op ::= ssa-id `=` `spv.GL.Round` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Round %0 : f32
-    %3 = spv.GLSL.Round %1 : vector<3xf16>
+    %2 = spv.GL.Round %0 : f32
+    %3 = spv.GL.Round %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLInverseSqrtOp : SPV_GLSLUnaryArithmeticOp<"InverseSqrt", 32, SPV_Float> {
+def SPV_GLInverseSqrtOp : SPV_GLUnaryArithmeticOp<"InverseSqrt", 32, SPV_Float> {
   let summary = "Reciprocal of sqrt(operand)";
 
   let description = [{
     Result is the reciprocal of sqrt x. Result is undefined if x <= 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    rsqrt-op ::= ssa-id `=` `spv.GLSL.InverseSqrt` ssa-use `:`
+    rsqrt-op ::= ssa-id `=` `spv.GL.InverseSqrt` ssa-use `:`
                  float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.InverseSqrt %0 : f32
-    %3 = spv.GLSL.InverseSqrt %1 : vector<3xf16>
+    %2 = spv.GL.InverseSqrt %0 : f32
+    %3 = spv.GL.InverseSqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLLogOp : SPV_GLSLUnaryArithmeticOp<"Log", 28, SPV_Float16or32> {
+def SPV_GLLogOp : SPV_GLUnaryArithmeticOp<"Log", 28, SPV_Float16or32> {
   let summary = "Natural logarithm of the operand";
 
   let description = [{
     Result is the natural logarithm of x, i.e., the value y which satisfies the
     equation x = ey. Result is undefined if x <= 0.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    log-op ::= ssa-id `=` `spv.GLSL.Log` ssa-use `:`
+    log-op ::= ssa-id `=` `spv.GL.Log` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Log %0 : f32
-    %3 = spv.GLSL.Log %1 : vector<3xf16>
+    %2 = spv.GL.Log %0 : f32
+    %3 = spv.GL.Log %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFMaxOp : SPV_GLSLBinaryArithmeticOp<"FMax", 40, SPV_Float> {
+def SPV_GLFMaxOp : SPV_GLBinaryArithmeticOp<"FMax", 40, SPV_Float> {
   let summary = "Return maximum of two floating-point operands";
 
   let description = [{
     Result is y if x < y; otherwise result is x. Which operand is the
     result is undefined if one of the operands is a NaN.
 
     The operands must all be a scalar or vector whose component type
     is floating-point.
 
     Result Type and the type of all operands must be the same
     type. Results are computed per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    fmax-op ::= ssa-id `=` `spv.GLSL.FMax` ssa-use `:`
+    fmax-op ::= ssa-id `=` `spv.GL.FMax` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FMax %0, %1 : f32
-    %3 = spv.GLSL.FMax %0, %1 : vector<3xf16>
+    %2 = spv.GL.FMax %0, %1 : f32
+    %3 = spv.GL.FMax %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLUMaxOp : SPV_GLSLBinaryArithmeticOp<"UMax", 41, SPV_Integer> {
+def SPV_GLUMaxOp : SPV_GLBinaryArithmeticOp<"UMax", 41, SPV_Integer> {
   let summary = "Return maximum of two unsigned integer operands";
 
   let description = [{
     Result is y if x < y; otherwise result is x, where x and y are interpreted
     as unsigned integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    smax-op ::= ssa-id `=` `spv.GLSL.UMax` ssa-use `:`
+    smax-op ::= ssa-id `=` `spv.GL.UMax` ssa-use `:`
                 integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.UMax %0, %1 : i32
-    %3 = spv.GLSL.UMax %0, %1 : vector<3xi16>
+    %2 = spv.GL.UMax %0, %1 : i32
+    %3 = spv.GL.UMax %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSMaxOp : SPV_GLSLBinaryArithmeticOp<"SMax", 42, SPV_Integer> {
+def SPV_GLSMaxOp : SPV_GLBinaryArithmeticOp<"SMax", 42, SPV_Integer> {
   let summary = "Return maximum of two signed integer operands";
 
   let description = [{
     Result is y if x < y; otherwise result is x, where x and y are interpreted
     as signed integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    smax-op ::= ssa-id `=` `spv.GLSL.SMax` ssa-use `:`
+    smax-op ::= ssa-id `=` `spv.GL.SMax` ssa-use `:`
                 integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.SMax %0, %1 : i32
-    %3 = spv.GLSL.SMax %0, %1 : vector<3xi16>
+    %2 = spv.GL.SMax %0, %1 : i32
+    %3 = spv.GL.SMax %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFMinOp : SPV_GLSLBinaryArithmeticOp<"FMin", 37, SPV_Float> {
+def SPV_GLFMinOp : SPV_GLBinaryArithmeticOp<"FMin", 37, SPV_Float> {
   let summary = "Return minimum of two floating-point operands";
 
   let description = [{
     Result is y if y < x; otherwise result is x. Which operand is the result is
     undefined if one of the operands is a NaN.
 
     The operands must all be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of all operands must be the same type. Results are
     computed per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    fmin-op ::= ssa-id `=` `spv.GLSL.FMin` ssa-use `:`
+    fmin-op ::= ssa-id `=` `spv.GL.FMin` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FMin %0, %1 : f32
-    %3 = spv.GLSL.FMin %0, %1 : vector<3xf16>
+    %2 = spv.GL.FMin %0, %1 : f32
+    %3 = spv.GL.FMin %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLUMinOp : SPV_GLSLBinaryArithmeticOp<"UMin", 38, SPV_Integer> {
+def SPV_GLUMinOp : SPV_GLBinaryArithmeticOp<"UMin", 38, SPV_Integer> {
   let summary = "Return minimum of two unsigned integer operands";
 
   let description = [{
     Result is y if y < x; otherwise result is x, where x and y are interpreted
     as unsigned integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    smin-op ::= ssa-id `=` `spv.GLSL.UMin` ssa-use `:`
+    smin-op ::= ssa-id `=` `spv.GL.UMin` ssa-use `:`
                 integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.UMin %0, %1 : i32
-    %3 = spv.GLSL.UMin %0, %1 : vector<3xi16>
+    %2 = spv.GL.UMin %0, %1 : i32
+    %3 = spv.GL.UMin %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSMinOp : SPV_GLSLBinaryArithmeticOp<"SMin", 39, SPV_Integer> {
+def SPV_GLSMinOp : SPV_GLBinaryArithmeticOp<"SMin", 39, SPV_Integer> {
   let summary = "Return minimum of two signed integer operands";
 
   let description = [{
     Result is y if y < x; otherwise result is x, where x and y are interpreted
     as signed integers.
 
     Result Type and the type of x and y must both be integer scalar or integer
     vector types. Result Type and operand types must have the same number of
     components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    smin-op ::= ssa-id `=` `spv.GLSL.SMin` ssa-use `:`
+    smin-op ::= ssa-id `=` `spv.GL.SMin` ssa-use `:`
                 integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.SMin %0, %1 : i32
-    %3 = spv.GLSL.SMin %0, %1 : vector<3xi16>
+    %2 = spv.GL.SMin %0, %1 : i32
+    %3 = spv.GL.SMin %0, %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLPowOp : SPV_GLSLBinaryArithmeticOp<"Pow", 26, SPV_Float16or32> {
+def SPV_GLPowOp : SPV_GLBinaryArithmeticOp<"Pow", 26, SPV_Float16or32> {
   let summary = "Return x raised to the y power of two operands";
 
   let description = [{
     Result is x raised to the y power; x^y.
 
     Result is undefined if x = 0 and y ≤ 0.
 
     The operand x and y must be a scalar or vector whose component type is
     16-bit or 32-bit floating-point.
 
     Result Type and the type of all operands must be the same type. Results are
     computed per component.
 
     <!-- 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.GLSL.Pow` ssa-use `:`
+    pow-op ::= ssa-id `=` `spv.GL.Pow` ssa-use `:`
                restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Pow %0, %1 : f32
-    %3 = spv.GLSL.Pow %0, %1 : vector<3xf16>
+    %2 = spv.GL.Pow %0, %1 : f32
+    %3 = spv.GL.Pow %0, %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFSignOp : SPV_GLSLUnaryArithmeticOp<"FSign", 6, SPV_Float> {
+def SPV_GLFSignOp : SPV_GLUnaryArithmeticOp<"FSign", 6, SPV_Float> {
   let summary = "Returns the sign of the operand";
 
   let description = [{
     Result is 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    sign-op ::= ssa-id `=` `spv.GLSL.FSign` ssa-use `:`
+    sign-op ::= ssa-id `=` `spv.GL.FSign` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FSign %0 : f32
-    %3 = spv.GLSL.FSign %1 : vector<3xf16>
+    %2 = spv.GL.FSign %0 : f32
+    %3 = spv.GL.FSign %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSSignOp : SPV_GLSLUnaryArithmeticOp<"SSign", 7, SPV_Integer> {
+def SPV_GLSSignOp : SPV_GLUnaryArithmeticOp<"SSign", 7, SPV_Integer> {
   let summary = "Returns the sign of the operand";
 
   let description = [{
     Result is 1 if x > 0, 0 if x = 0, or -1 if x < 0, where x is interpreted as
     a signed integer.
 
     Result Type and the type of x must both be integer scalar or integer vector
     types. Result Type and operand types must have the same number of components
     with the same component width. Results are computed per component.
 
     <!-- End of AutoGen section -->
     ```
     integer-scalar-vector-type ::= integer-type |
                                    `vector<` integer-literal `x` integer-type `>`
-    sign-op ::= ssa-id `=` `spv.GLSL.SSign` ssa-use `:`
+    sign-op ::= ssa-id `=` `spv.GL.SSign` ssa-use `:`
                 integer-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.SSign %0 : i32
-    %3 = spv.GLSL.SSign %1 : vector<3xi16>
+    %2 = spv.GL.SSign %0 : i32
+    %3 = spv.GL.SSign %1 : vector<3xi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSqrtOp : SPV_GLSLUnaryArithmeticOp<"Sqrt", 31, SPV_Float> {
+def SPV_GLSqrtOp : SPV_GLUnaryArithmeticOp<"Sqrt", 31, SPV_Float> {
   let summary = "Returns the square root of the operand";
 
   let description = [{
     Result is the square root of x. Result is undefined if x < 0.
 
     The operand x must be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
-    sqrt-op ::= ssa-id `=` `spv.GLSL.Sqrt` ssa-use `:`
+    sqrt-op ::= ssa-id `=` `spv.GL.Sqrt` ssa-use `:`
                 float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Sqrt %0 : f32
-    %3 = spv.GLSL.Sqrt %1 : vector<3xf16>
+    %2 = spv.GL.Sqrt %0 : f32
+    %3 = spv.GL.Sqrt %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSinhOp : SPV_GLSLUnaryArithmeticOp<"Sinh", 19, SPV_Float16or32> {
+def SPV_GLSinhOp : SPV_GLUnaryArithmeticOp<"Sinh", 19, SPV_Float16or32> {
   let summary = "Hyperbolic sine of operand in radians";
 
   let description = [{
     Hyperbolic sine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    sinh-op ::= ssa-id `=` `spv.GLSL.Sinh` ssa-use `:`
+    sinh-op ::= ssa-id `=` `spv.GL.Sinh` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Sinh %0 : f32
-    %3 = spv.GLSL.Sinh %1 : vector<3xf16>
+    %2 = spv.GL.Sinh %0 : f32
+    %3 = spv.GL.Sinh %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLCoshOp : SPV_GLSLUnaryArithmeticOp<"Cosh", 20, SPV_Float16or32> {
+def SPV_GLCoshOp : SPV_GLUnaryArithmeticOp<"Cosh", 20, SPV_Float16or32> {
   let summary = "Hyperbolic cosine of operand in radians";
 
   let description = [{
     Hyperbolic cosine of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    cosh-op ::= ssa-id `=` `spv.GLSL.Cosh` ssa-use `:`
+    cosh-op ::= ssa-id `=` `spv.GL.Cosh` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Cosh %0 : f32
-    %3 = spv.GLSL.Cosh %1 : vector<3xf16>
+    %2 = spv.GL.Cosh %0 : f32
+    %3 = spv.GL.Cosh %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLTanhOp : SPV_GLSLUnaryArithmeticOp<"Tanh", 21, SPV_Float16or32> {
+def SPV_GLTanhOp : SPV_GLUnaryArithmeticOp<"Tanh", 21, SPV_Float16or32> {
   let summary = "Hyperbolic tangent of operand in radians";
 
   let description = [{
     Hyperbolic tangent of x radians.
 
     The operand x must be a scalar or vector whose component type is 16-bit or
     32-bit floating-point.
 
     Result Type and the type of x must be the same type. Results are computed
     per component.
 
     <!-- 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 `>`
-    tanh-op ::= ssa-id `=` `spv.GLSL.Tanh` ssa-use `:`
+    tanh-op ::= ssa-id `=` `spv.GL.Tanh` ssa-use `:`
                 restricted-float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.Tanh %0 : f32
-    %3 = spv.GLSL.Tanh %1 : vector<3xf16>
+    %2 = spv.GL.Tanh %0 : f32
+    %3 = spv.GL.Tanh %1 : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFClampOp : SPV_GLSLTernaryArithmeticOp<"FClamp", 43, SPV_Float> {
+def SPV_GLFClampOp : SPV_GLTernaryArithmeticOp<"FClamp", 43, SPV_Float> {
   let summary = "Clamp x between min and max values.";
 
   let description = [{
     Result is min(max(x, minVal), maxVal). The resulting value is undefined if
     minVal > maxVal. The semantics used by min() and max() are those of FMin and
     FMax.
 
     The operands must all be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of all operands must be the same type. Results are
     computed per component.
 
     <!-- End of AutoGen section -->
     ```
-    fclamp-op ::= ssa-id `=` `spv.GLSL.FClamp` ssa-use, ssa-use, ssa-use `:`
+    fclamp-op ::= ssa-id `=` `spv.GL.FClamp` ssa-use, ssa-use, ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FClamp %x, %min, %max : f32
-    %3 = spv.GLSL.FClamp %x, %min, %max : vector<3xf16>
+    %2 = spv.GL.FClamp %x, %min, %max : f32
+    %3 = spv.GL.FClamp %x, %min, %max : vector<3xf16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLUClampOp : SPV_GLSLTernaryArithmeticOp<"UClamp", 44, SPV_Integer> {
+def SPV_GLUClampOp : SPV_GLTernaryArithmeticOp<"UClamp", 44, SPV_Integer> {
   let summary = "Clamp x between min and max values.";
 
   let description = [{
     Result is min(max(x, minVal), maxVal), where x, minVal and maxVal are
     interpreted as unsigned integers. The resulting value is undefined if
     minVal > maxVal.
 
     Result Type and the type of the operands must both be integer scalar or
     integer vector types. Result Type and operand types must have the same number
     of components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
-    uclamp-op ::= ssa-id `=` `spv.GLSL.UClamp` ssa-use, ssa-use, ssa-use `:`
+    uclamp-op ::= ssa-id `=` `spv.GL.UClamp` ssa-use, ssa-use, ssa-use `:`
                unsigned-signless-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.UClamp %x, %min, %max : i32
-    %3 = spv.GLSL.UClamp %x, %min, %max : vector<3xui16>
+    %2 = spv.GL.UClamp %x, %min, %max : i32
+    %3 = spv.GL.UClamp %x, %min, %max : vector<3xui16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLSClampOp : SPV_GLSLTernaryArithmeticOp<"SClamp", 45, SPV_Integer> {
+def SPV_GLSClampOp : SPV_GLTernaryArithmeticOp<"SClamp", 45, SPV_Integer> {
   let summary = "Clamp x between min and max values.";
 
   let description = [{
     Result is min(max(x, minVal), maxVal), where x, minVal and maxVal are
     interpreted as signed integers. The resulting value is undefined if
     minVal > maxVal.
 
     Result Type and the type of the operands must both be integer scalar or
     integer vector types. Result Type and operand types must have the same number
     of components with the same component width. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
     ```
-    uclamp-op ::= ssa-id `=` `spv.GLSL.UClamp` ssa-use, ssa-use, ssa-use `:`
+    uclamp-op ::= ssa-id `=` `spv.GL.UClamp` ssa-use, ssa-use, ssa-use `:`
                sgined-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.SClamp %x, %min, %max : si32
-    %3 = spv.GLSL.SClamp %x, %min, %max : vector<3xsi16>
+    %2 = spv.GL.SClamp %x, %min, %max : si32
+    %3 = spv.GL.SClamp %x, %min, %max : vector<3xsi16>
     ```
   }];
 }
 
 // -----
 
-def SPV_GLSLFmaOp : SPV_GLSLTernaryArithmeticOp<"Fma", 50, SPV_Float> {
+def SPV_GLFmaOp : SPV_GLTernaryArithmeticOp<"Fma", 50, SPV_Float> {
   let summary = "Computes a * b + c.";
 
   let description = [{
     In uses where this operation is decorated with NoContraction:
 
     - fma is considered a single operation, whereas the expression a * b + c
       is considered two operations.
     - The precision of fma can differ from the precision of the expression
let description = [{
     The operands must all be a scalar or vector whose component type is
     floating-point.
 
     Result Type and the type of all operands must be the same type. Results
     are computed per component.
 
     <!-- End of AutoGen section -->
     ```
-    fma-op ::= ssa-id `=` `spv.GLSL.Fma` ssa-use, ssa-use, ssa-use `:`
+    fma-op ::= ssa-id `=` `spv.GL.Fma` ssa-use, ssa-use, ssa-use `:`
                float-scalar-vector-type
     ```
     #### Example:
 
     ```mlir
-    %0 = spv.GLSL.Fma %a, %b, %c : f32
-    %1 = spv.GLSL.Fma %a, %b, %c : vector<3xf16>
+    %0 = spv.GL.Fma %a, %b, %c : f32
+    %1 = spv.GL.Fma %a, %b, %c : vector<3xf16>
     ```
   }];
 }
 
 // ----
 
-def SPV_GLSLFrexpStructOp : SPV_GLSLOp<"FrexpStruct", 52, [NoSideEffect]> {
+def SPV_GLFrexpStructOp : SPV_GLOp<"FrexpStruct", 52, [NoSideEffect]> {
   let summary = "Splits x into two components such that x = significand * 2^exponent";
 
   let description = [{
     Result is a structure containing x split into a floating-point significand
     in the range (-1.0, 0.5] or [0.5, 1.0) and an integral exponent of 2, such that:
 
     x = significand * 2^exponent
 
let description = [{
     floating-point.
 
     <!-- End of AutoGen section -->
     ```
     float-scalar-vector-type ::= float-type |
                                  `vector<` integer-literal `x` float-type `>`
     integer-scalar-vector-type ::= integer-type |
                                  `vector<` integer-literal `x` integer-type `>`
-    frexpstruct-op ::= ssa-id `=` `spv.GLSL.FrexpStruct` ssa-use `:`
+    frexpstruct-op ::= ssa-id `=` `spv.GL.FrexpStruct` ssa-use `:`
                                   `!spv.struct<` float-scalar-vector-type `,`
                                                   integer-scalar-vector-type `>`
     ```
     #### Example:
 
     ```mlir
-    %2 = spv.GLSL.FrexpStruct %0 : f32 -> !spv.struct<f32, i32>
-    %3 = spv.GLSL.FrexpStruct %0 : vector<3xf32> -> !spv.struct<vector<3xf32>, vector<3xi32>>
+    %2 = spv.GL.FrexpStruct %0 : f32 -> !spv.struct<f32, i32>
+    %3 = spv.GL.FrexpStruct %0 : vector<3xf32> -> !spv.struct<vector<3xf32>, vector<3xi32>>
     ```
   }];
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<SPV_Float>:$operand
   );
 
   let results = (outs
     SPV_AnyStruct:$result
   );
 
   let assemblyFormat = [{
     attr-dict $operand `:` type($operand) `->` type($result)
   }];
 }
 
-def SPV_GLSLLdexpOp :
-  SPV_GLSLOp<"Ldexp", 53, [
+def SPV_GLLdexpOp :
+  SPV_GLOp<"Ldexp", 53, [
       NoSideEffect, AllTypesMatch<["x", "y"]>]> {
   let summary = "Builds y such that y = significand * 2^exponent";
 
   let description = [{
     Builds a floating-point number from x and the corresponding
     integral exponent of two in exp:
 
     significand * 2^exponent
let description = [{
     Result Type must be the same type as the type of x. Results are computed per
     component.
 
     <!-- End of AutoGen section -->
 
     #### Example:
 
     ```mlir
-    %y = spv.GLSL.Ldexp %x : f32, %exp : i32 -> f32
-    %y = spv.GLSL.Ldexp %x : vector<3xf32>, %exp : vector<3xi32> -> vector<3xf32>
+    %y = spv.GL.Ldexp %x : f32, %exp : i32 -> f32
+    %y = spv.GL.Ldexp %x : vector<3xf32>, %exp : vector<3xi32> -> vector<3xf32>
     ```
   }];
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<SPV_Float>:$x,
     SPV_ScalarOrVectorOf<SPV_Integer>:$exp
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<SPV_Float>:$y
   );
 
   let assemblyFormat = [{
     attr-dict $x `:` type($x) `,` $exp `:` type($exp) `->` type($y)
   }];
 }
 
-def SPV_GLSLFMixOp :
-  SPV_GLSLOp<"FMix", 46, [
+def SPV_GLFMixOp :
+  SPV_GLOp<"FMix", 46, [
       NoSideEffect, AllTypesMatch<["x", "y", "a", "result"]>]> {
   let summary = "Builds the linear blend of x and y";
 
   let description = [{
     Result is the linear blend of x and y, i.e., x * (1 - a) + y * a.
 
     The operands must all be a scalar or vector whose component type is floating-point.
 
     Result Type and the type of all operands must be the same type. Results are computed per component.
 
     <!-- End of AutoGen section -->
 
     #### Example:
 
     ```mlir
-    %0 = spv.GLSL.FMix %x : f32, %y : f32, %a : f32 -> f32
-    %0 = spv.GLSL.FMix %x : vector<4xf32>, %y : vector<4xf32>, %a : vector<4xf32> -> vector<4xf32>
+    %0 = spv.GL.FMix %x : f32, %y : f32, %a : f32 -> f32
+    %0 = spv.GL.FMix %x : vector<4xf32>, %y : vector<4xf32>, %a : vector<4xf32> -> vector<4xf32>
     ```
   }];
 
   let arguments = (ins
     SPV_ScalarOrVectorOf<SPV_Float>:$x,
     SPV_ScalarOrVectorOf<SPV_Float>:$y,
     SPV_ScalarOrVectorOf<SPV_Float>:$a
   );
 
   let results = (outs
     SPV_ScalarOrVectorOf<SPV_Float>:$result
   );
 
   let assemblyFormat = [{
     attr-dict $x `:` type($x) `,` $y `:` type($y) `,` $a `:` type($a) `->` type($result)
   }];
 
   let hasVerifier = 0;
 }
 
-def SPV_GLSLFindUMsbOp : SPV_GLSLUnaryArithmeticOp<"FindUMsb", 75, SPV_Int32> {
+def SPV_GLFindUMsbOp : SPV_GLUnaryArithmeticOp<"FindUMsb", 75, SPV_Int32> {
   let summary = "Unsigned-integer most-significant bit";
 
   let description = [{
     Results in the bit number of the most-significant 1-bit in the binary
     representation of Value. If Value is 0, the result is -1.
 
     Result Type and the type of Value must both be integer scalar or
     integer vector types. Result Type and operand types must have the
     same number of components with the same component width. Results are
     computed per component.
 
     This instruction is currently limited to 32-bit width components.
   }];
 }
 
-#endif // MLIR_DIALECT_SPIRV_IR_GLSL_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_GL_OPS

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

let results = (outs
     SPV_AnyImage:$result
   );
 
   let assemblyFormat = "attr-dict $sampledimage `:` type($sampledimage)";
 
   let hasVerifier = 0;
 }
 
-#endif // MLIR_DIALECT_SPIRV_IR_GLSL_OPS
+#endif // MLIR_DIALECT_SPIRV_IR_GL_OPS

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

 include "mlir/Dialect/SPIRV/IR/SPIRVArithmeticOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVAtomicOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVBarrierOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVBitOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVCastOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVCompositeOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVControlFlowOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVCooperativeMatrixOps.td"
-include "mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td"
+include "mlir/Dialect/SPIRV/IR/SPIRVGLOps.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/SPIRVCLOps.td"
 include "mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 #endif // MLIR_DIALECT_SPIRV_IR_OPS

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.h

 namespace spirv {
 
 class ModuleOp;
 
 //===----------------------------------------------------------------------===//
 // Passes
 //===----------------------------------------------------------------------===//
 
-/// Creates a pass to run canoncalization patterns that involve GLSL ops.
-/// These patterns cannot be run in default canonicalization because GLSL ops
+/// Creates a pass to run canoncalization patterns that involve GL ops.
+/// These patterns cannot be run in default canonicalization because GL ops
 /// aren't always available. So they should be involed specifically when needed.
-std::unique_ptr<OperationPass<>> createCanonicalizeGLSLPass();
+std::unique_ptr<OperationPass<>> createCanonicalizeGLPass();
 
 /// Creates a module pass that converts composite types used by objects in the
 /// StorageBuffer, PhysicalStorageBuffer, Uniform, and PushConstant storage
 /// classes with layout information.
 /// Right now this pass only supports Vulkan layout rules.
 std::unique_ptr<OperationPass<mlir::ModuleOp>>
 createDecorateSPIRVCompositeTypeLayoutPass();
 

mlir/include/mlir/Dialect/SPIRV/Transforms/Passes.td

 include "mlir/Pass/PassBase.td"
 
 def SPIRVCompositeTypeLayout
     : Pass<"decorate-spirv-composite-type-layout", "ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
   let constructor = "mlir::spirv::createDecorateSPIRVCompositeTypeLayoutPass()";
 }
 
-def SPIRVCanonicalizeGLSL : Pass<"spirv-canonicalize-glsl", ""> {
+def SPIRVCanonicalizeGL : Pass<"spirv-canonicalize-gl", ""> {
   let summary = "Run canonicalization involving GLSL ops";
-  let constructor = "mlir::spirv::createCanonicalizeGLSLPass()";
+  let constructor = "mlir::spirv::createCanonicalizeGLPass()";
 }
 
 def SPIRVLowerABIAttributes : Pass<"spirv-lower-abi-attrs", "spirv::ModuleOp"> {
   let summary = "Decorate SPIR-V composite type with layout info";
   let constructor = "mlir::spirv::createLowerABIAttributesPass()";
 }
 
 def SPIRVRewriteInsertsPass : Pass<"spirv-rewrite-inserts", "spirv::ModuleOp"> {

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

struct ConstantScalarOpPattern final
   matchAndRewrite(arith::ConstantOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 
 /// Converts arith.remsi to GLSL SPIR-V ops.
 ///
 /// This cannot be merged into the template unary/binary pattern due to Vulkan
 /// restrictions over spv.SRem and spv.SMod.
-struct RemSIOpGLSLPattern final : public OpConversionPattern<arith::RemSIOp> {
+struct RemSIOpGLPattern 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.
auto dstAttr =
       convertIntegerAttr(srcAttr, dstType.cast<IntegerType>(), rewriter);
   if (!dstAttr)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// RemSIOpGLSLPattern
+// RemSIOpGLPattern
 //===----------------------------------------------------------------------===//
 
 /// Returns signed remainder for `lhs` and `rhs` and lets the result follow
 /// the sign of `signOperand`.
 ///
 /// Note that this is needed for Vulkan. Per the Vulkan's SPIR-V environment
 /// spec, "for the OpSRem and OpSMod instructions, if either operand is negative
 /// the result is undefined."  So we cannot directly use spv.SRem/spv.SMod
if (lhs == signOperand)
     isPositive = builder.create<spirv::IEqualOp>(loc, lhs, lhsAbs);
   else
     isPositive = builder.create<spirv::IEqualOp>(loc, rhs, rhsAbs);
   Value absNegate = builder.create<spirv::SNegateOp>(loc, type, abs);
   return builder.create<spirv::SelectOp>(loc, type, isPositive, abs, absNegate);
 }
 
 LogicalResult
-RemSIOpGLSLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
-                                    ConversionPatternRewriter &rewriter) const {
-  Value result = emulateSignedRemainder<spirv::GLSLSAbsOp>(
+RemSIOpGLPattern::matchAndRewrite(arith::RemSIOp op, OpAdaptor adaptor,
+  Value result = emulateSignedRemainder<spirv::GLSAbsOp>(
       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, RemSIOpCLPattern,
+    RemSIOpGLPattern, 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>,
patterns.add<
     TypeCastingOpPattern<arith::SIToFPOp, spirv::ConvertSToFOp>,
     TypeCastingOpPattern<arith::FPToSIOp, spirv::ConvertFToSOp>,
     TypeCastingOpPattern<arith::IndexCastOp, spirv::SConvertOp>,
     TypeCastingOpPattern<arith::BitcastOp, spirv::BitcastOp>,
     CmpIOpBooleanPattern, CmpIOpPattern,
     CmpFOpNanNonePattern, CmpFOpPattern,
     SelectOpPattern,
 
-    spirv::ElementwiseOpPattern<arith::MaxFOp, spirv::GLSLFMaxOp>,
-    spirv::ElementwiseOpPattern<arith::MaxSIOp, spirv::GLSLSMaxOp>,
-    spirv::ElementwiseOpPattern<arith::MaxUIOp, spirv::GLSLUMaxOp>,
-    spirv::ElementwiseOpPattern<arith::MinFOp, spirv::GLSLFMinOp>,
-    spirv::ElementwiseOpPattern<arith::MinSIOp, spirv::GLSLSMinOp>,
-    spirv::ElementwiseOpPattern<arith::MinUIOp, spirv::GLSLUMinOp>
+    spirv::ElementwiseOpPattern<arith::MaxFOp, spirv::GLFMaxOp>,
+    spirv::ElementwiseOpPattern<arith::MaxSIOp, spirv::GLSMaxOp>,
+    spirv::ElementwiseOpPattern<arith::MaxUIOp, spirv::GLUMaxOp>,
+    spirv::ElementwiseOpPattern<arith::MinFOp, spirv::GLFMinOp>,
+    spirv::ElementwiseOpPattern<arith::MinSIOp, spirv::GLSMinOp>,
+    spirv::ElementwiseOpPattern<arith::MinUIOp, spirv::GLUMinOp>
   >(typeConverter, patterns.getContext());
   // clang-format on
 
   // Give CmpFOpNanKernelPattern a higher benefit so it can prevail when Kernel
   // capability is available.
   patterns.add<CmpFOpNanKernelPattern>(typeConverter, patterns.getContext(),
                                        /*benefit=*/2);
 }

mlir/lib/Conversion/MathToSPIRV/MathToSPIRV.cpp

matchAndRewrite(math::CopySignOp copySignOp, OpAdaptor adaptor,
     rewriter.replaceOpWithNewOp<spirv::BitcastOp>(copySignOp, type, result);
     return success();
   }
 };
 
 /// Converts math.ctlz to SPIR-V ops.
 ///
 /// SPIR-V does not have a direct operations for counting leading zeros. If
-/// Shader capability is supported, we can leverage GLSL FindUMsb to calculate
+/// Shader capability is supported, we can leverage GL FindUMsb to calculate
 /// it.
 class CountLeadingZerosPattern final
     : public OpConversionPattern<math::CountLeadingZerosOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(math::CountLeadingZerosOp countOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
if (bitwidth != 32)
       return failure();
 
     Location loc = countOp.getLoc();
     Value input = adaptor.getOperand();
     Value val1 = getScalarOrVectorI32Constant(type, 1, rewriter, loc);
     Value val31 = getScalarOrVectorI32Constant(type, 31, rewriter, loc);
     Value val32 = getScalarOrVectorI32Constant(type, 32, rewriter, loc);
 
-    Value msb = rewriter.create<spirv::GLSLFindUMsbOp>(loc, input);
+    Value msb = rewriter.create<spirv::GLFindUMsbOp>(loc, input);
     // We need to subtract from 31 given that the index returned by GLSL
     // FindUMsb is counted from the least significant bit. Theoretically this
     // also gives the correct result even if the integer has all zero bits, in
-    // which case GLSL FindUMsb would return -1.
+    // which case GL FindUMsb would return -1.
     Value subMsb = rewriter.create<spirv::ISubOp>(loc, val31, msb);
     // However, certain Vulkan implementations have driver bugs for the corner
     // case where the input is zero. And.. it can be smart to optimize a select
     // only involving the corner case. So separately compute the result when the
     // input is either zero or one.
     Value subInput = rewriter.create<spirv::ISubOp>(loc, val32, input);
     Value cmp = rewriter.create<spirv::ULessThanEqualOp>(loc, input, val1);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(countOp, cmp, subInput,
struct PowFOpPattern final : public OpConversionPattern<math::PowFOp> {
 
   LogicalResult
   matchAndRewrite(math::PowFOp powfOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(powfOp.getType());
     if (!dstType)
       return failure();
 
-    // Per GLSL Pow extended instruction spec:
+    // Per GL Pow extended instruction spec:
     // "Result is undefined if x < 0. Result is undefined if x = 0 and y <= 0."
     Location loc = powfOp.getLoc();
     Value zero =
         spirv::ConstantOp::getZero(adaptor.getLhs().getType(), loc, rewriter);
     Value lessThan =
         rewriter.create<spirv::FOrdLessThanOp>(loc, adaptor.getLhs(), zero);
-    Value abs = rewriter.create<spirv::GLSLFAbsOp>(loc, adaptor.getLhs());
-    Value pow = rewriter.create<spirv::GLSLPowOp>(loc, abs, adaptor.getRhs());
+    Value abs = rewriter.create<spirv::GLFAbsOp>(loc, adaptor.getLhs());
+    Value pow = rewriter.create<spirv::GLPowOp>(loc, abs, adaptor.getRhs());
     Value negate = rewriter.create<spirv::FNegateOp>(loc, pow);
     rewriter.replaceOpWithNewOp<spirv::SelectOp>(powfOp, lessThan, negate, pow);
     return success();
   }
 };
 
 /// Converts math.round to GLSL SPIRV extended ops.
 struct RoundOpPattern final : public OpConversionPattern<math::RoundOp> {
if (VectorType vty = ty.dyn_cast<VectorType>()) {
           loc, vty,
           DenseElementsAttr::get(vty,
                                  rewriter.getFloatAttr(ety, 0.5).getValue()));
     } else {
       half = rewriter.create<spirv::ConstantOp>(
           loc, ty, rewriter.getFloatAttr(ety, 0.5));
     }
 
-    auto abs = rewriter.create<spirv::GLSLFAbsOp>(loc, operand);
-    auto floor = rewriter.create<spirv::GLSLFloorOp>(loc, abs);
+    auto abs = rewriter.create<spirv::GLFAbsOp>(loc, operand);
+    auto floor = rewriter.create<spirv::GLFloorOp>(loc, abs);
     auto sub = rewriter.create<spirv::FSubOp>(loc, abs, floor);
     auto greater =
         rewriter.create<spirv::FOrdGreaterThanEqualOp>(loc, sub, half);
     auto select = rewriter.create<spirv::SelectOp>(loc, greater, one, zero);
     auto add = rewriter.create<spirv::FAddOp>(loc, floor, select);
     rewriter.replaceOpWithNewOp<math::CopySignOp>(roundOp, add, operand);
     return success();
   }
 };
 
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
 void populateMathToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
                                  RewritePatternSet &patterns) {
   // Core patterns
   patterns.add<CopySignPattern>(typeConverter, patterns.getContext());
 
   // GLSL patterns
   patterns
-      .add<CountLeadingZerosPattern, Log1pOpPattern<spirv::GLSLLogOp>,
-           ExpM1OpPattern<spirv::GLSLExpOp>, PowFOpPattern, RoundOpPattern,
-           spirv::ElementwiseOpPattern<math::AbsOp, spirv::GLSLFAbsOp>,
-           spirv::ElementwiseOpPattern<math::CeilOp, spirv::GLSLCeilOp>,
-           spirv::ElementwiseOpPattern<math::CosOp, spirv::GLSLCosOp>,
-           spirv::ElementwiseOpPattern<math::ExpOp, spirv::GLSLExpOp>,
-           spirv::ElementwiseOpPattern<math::FloorOp, spirv::GLSLFloorOp>,
-           spirv::ElementwiseOpPattern<math::FmaOp, spirv::GLSLFmaOp>,
-           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>>(
+      .add<CountLeadingZerosPattern, Log1pOpPattern<spirv::GLLogOp>,
+           ExpM1OpPattern<spirv::GLExpOp>, PowFOpPattern, RoundOpPattern,
+           spirv::ElementwiseOpPattern<math::AbsOp, spirv::GLFAbsOp>,
+           spirv::ElementwiseOpPattern<math::CeilOp, spirv::GLCeilOp>,
+           spirv::ElementwiseOpPattern<math::CosOp, spirv::GLCosOp>,
+           spirv::ElementwiseOpPattern<math::ExpOp, spirv::GLExpOp>,
+           spirv::ElementwiseOpPattern<math::FloorOp, spirv::GLFloorOp>,
+           spirv::ElementwiseOpPattern<math::FmaOp, spirv::GLFmaOp>,
+           spirv::ElementwiseOpPattern<math::LogOp, spirv::GLLogOp>,
+           spirv::ElementwiseOpPattern<math::RsqrtOp, spirv::GLInverseSqrtOp>,
+           spirv::ElementwiseOpPattern<math::SinOp, spirv::GLSinOp>,
+           spirv::ElementwiseOpPattern<math::SqrtOp, spirv::GLSqrtOp>,
+           spirv::ElementwiseOpPattern<math::TanhOp, spirv::GLTanhOp>>(
           typeConverter, patterns.getContext());
 
   // OpenCL patterns
   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>,

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
     rewriter.template replaceOpWithNewOp<LLVM::ICmpOp>(
         operation, dstType, predicate, operation.operand1(),
         operation.operand2());
     return success();
   }
 };
 
 class InverseSqrtPattern
-    : public SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp> {
+    : public SPIRVToLLVMConversion<spirv::GLInverseSqrtOp> {
 public:
-  using SPIRVToLLVMConversion<spirv::GLSLInverseSqrtOp>::SPIRVToLLVMConversion;
+  using SPIRVToLLVMConversion<spirv::GLInverseSqrtOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLInverseSqrtOp op, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLInverseSqrtOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = op.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = op.getLoc();
     Value one = createFPConstant(loc, srcType, dstType, rewriter, 1.0);
matchAndRewrite(SPIRVOp operation, typename SPIRVOp::Adaptor adaptor,
     }
     Value result = rewriter.template create<LLVMOp>(
         loc, dstType, adaptor.operand1(), extended);
     rewriter.replaceOp(operation, result);
     return success();
   }
 };
 
-class TanPattern : public SPIRVToLLVMConversion<spirv::GLSLTanOp> {
+class TanPattern : public SPIRVToLLVMConversion<spirv::GLTanOp> {
 public:
-  using SPIRVToLLVMConversion<spirv::GLSLTanOp>::SPIRVToLLVMConversion;
+  using SPIRVToLLVMConversion<spirv::GLTanOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanOp tanOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLTanOp tanOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = typeConverter.convertType(tanOp.getType());
     if (!dstType)
       return failure();
 
     Location loc = tanOp.getLoc();
     Value sin = rewriter.create<LLVM::SinOp>(loc, dstType, tanOp.operand());
     Value cos = rewriter.create<LLVM::CosOp>(loc, dstType, tanOp.operand());
     rewriter.replaceOpWithNewOp<LLVM::FDivOp>(tanOp, dstType, sin, cos);
     return success();
   }
 };
 
 /// Convert `spv.Tanh` to
 ///
 ///   exp(2x) - 1
 ///   -----------
 ///   exp(2x) + 1
 ///
-class TanhPattern : public SPIRVToLLVMConversion<spirv::GLSLTanhOp> {
+class TanhPattern : public SPIRVToLLVMConversion<spirv::GLTanhOp> {
 public:
-  using SPIRVToLLVMConversion<spirv::GLSLTanhOp>::SPIRVToLLVMConversion;
+  using SPIRVToLLVMConversion<spirv::GLTanhOp>::SPIRVToLLVMConversion;
 
   LogicalResult
-  matchAndRewrite(spirv::GLSLTanhOp tanhOp, OpAdaptor adaptor,
+  matchAndRewrite(spirv::GLTanhOp tanhOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto srcType = tanhOp.getType();
     auto dstType = typeConverter.convertType(srcType);
     if (!dstType)
       return failure();
 
     Location loc = tanhOp.getLoc();
     Value two = createFPConstant(loc, srcType, dstType, rewriter, 2.0);
patterns.add<
       BranchConversionPattern, BranchConditionalConversionPattern,
       FunctionCallPattern, LoopPattern, SelectionPattern,
       ErasePattern<spirv::MergeOp>,
 
       // Entry points and execution mode are handled separately.
       ErasePattern<spirv::EntryPointOp>, ExecutionModePattern,
 
       // GLSL extended instruction set ops
-      DirectConversionPattern<spirv::GLSLCeilOp, LLVM::FCeilOp>,
-      DirectConversionPattern<spirv::GLSLCosOp, LLVM::CosOp>,
-      DirectConversionPattern<spirv::GLSLExpOp, LLVM::ExpOp>,
-      DirectConversionPattern<spirv::GLSLFAbsOp, LLVM::FAbsOp>,
-      DirectConversionPattern<spirv::GLSLFloorOp, LLVM::FFloorOp>,
-      DirectConversionPattern<spirv::GLSLFMaxOp, LLVM::MaxNumOp>,
-      DirectConversionPattern<spirv::GLSLFMinOp, LLVM::MinNumOp>,
-      DirectConversionPattern<spirv::GLSLLogOp, LLVM::LogOp>,
-      DirectConversionPattern<spirv::GLSLSinOp, LLVM::SinOp>,
-      DirectConversionPattern<spirv::GLSLSMaxOp, LLVM::SMaxOp>,
-      DirectConversionPattern<spirv::GLSLSMinOp, LLVM::SMinOp>,
-      DirectConversionPattern<spirv::GLSLSqrtOp, LLVM::SqrtOp>,
+      DirectConversionPattern<spirv::GLCeilOp, LLVM::FCeilOp>,
+      DirectConversionPattern<spirv::GLCosOp, LLVM::CosOp>,
+      DirectConversionPattern<spirv::GLExpOp, LLVM::ExpOp>,
+      DirectConversionPattern<spirv::GLFAbsOp, LLVM::FAbsOp>,
+      DirectConversionPattern<spirv::GLFloorOp, LLVM::FFloorOp>,
+      DirectConversionPattern<spirv::GLFMaxOp, LLVM::MaxNumOp>,
+      DirectConversionPattern<spirv::GLFMinOp, LLVM::MinNumOp>,
+      DirectConversionPattern<spirv::GLLogOp, LLVM::LogOp>,
+      DirectConversionPattern<spirv::GLSinOp, LLVM::SinOp>,
+      DirectConversionPattern<spirv::GLSMaxOp, LLVM::SMaxOp>,
+      DirectConversionPattern<spirv::GLSMinOp, LLVM::SMinOp>,
+      DirectConversionPattern<spirv::GLSqrtOp, LLVM::SqrtOp>,
       InverseSqrtPattern, TanPattern, TanhPattern,
 
       // Logical ops
       DirectConversionPattern<spirv::LogicalAndOp, LLVM::AndOp>,
       DirectConversionPattern<spirv::LogicalOrOp, LLVM::OrOp>,
       IComparePattern<spirv::LogicalEqualOp, LLVM::ICmpPredicate::eq>,
       IComparePattern<spirv::LogicalNotEqualOp, LLVM::ICmpPredicate::ne>,
       NotPattern<spirv::LogicalNotOp>,

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

struct VectorFmaOpConvert final : public OpConversionPattern<vector::FMAOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::FMAOp fmaOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Type dstType = getTypeConverter()->convertType(fmaOp.getType());
     if (!dstType)
       return failure();
-    rewriter.replaceOpWithNewOp<spirv::GLSLFmaOp>(
+    rewriter.replaceOpWithNewOp<spirv::GLFmaOp>(
         fmaOp, dstType, adaptor.getLhs(), adaptor.getRhs(), adaptor.getAcc());
     return success();
   }
 };
 
 struct VectorInsertOpConvert final
     : public OpConversionPattern<vector::InsertOp> {
   using OpConversionPattern::OpConversionPattern;

mlir/lib/Dialect/SPIRV/IR/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS SPIRVCanonicalization.td)
 mlir_tablegen(SPIRVCanonicalization.inc -gen-rewriters)
 add_public_tablegen_target(MLIRSPIRVCanonicalizationIncGen)
 
 add_mlir_dialect_library(MLIRSPIRVDialect
   SPIRVAttributes.cpp
   SPIRVCanonicalization.cpp
-  SPIRVGLSLCanonicalization.cpp
+  SPIRVGLCanonicalization.cpp
   SPIRVDialect.cpp
   SPIRVEnums.cpp
   SPIRVOps.cpp
   SPIRVTypes.cpp
   TargetAndABI.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV

mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.td

def ConvertLogicalNotOfLogicalEqual : Pat<
     (SPV_LogicalNotOp (SPV_LogicalEqualOp $lhs, $rhs)),
     (SPV_LogicalNotEqualOp $lhs, $rhs)>;
 
 def ConvertLogicalNotOfLogicalNotEqual : Pat<
     (SPV_LogicalNotOp (SPV_LogicalNotEqualOp $lhs, $rhs)),
     (SPV_LogicalEqualOp $lhs, $rhs)>;
 
 //===----------------------------------------------------------------------===//
-// spv.Select -> spv.GLSL.*Clamp
+// spv.Select -> spv.GL.*Clamp
 //===----------------------------------------------------------------------===//
 
 def ValuesAreEqual : Constraint<CPred<"$0 == $1">>;
 
 foreach CmpClampPair = [
-    [SPV_FOrdLessThanOp, SPV_GLSLFClampOp],
-    [SPV_FOrdLessThanEqualOp, SPV_GLSLFClampOp],
-    [SPV_SLessThanOp, SPV_GLSLSClampOp],
-    [SPV_SLessThanEqualOp, SPV_GLSLSClampOp],
-    [SPV_ULessThanOp, SPV_GLSLUClampOp],
-    [SPV_ULessThanEqualOp, SPV_GLSLUClampOp]] in {
+    [SPV_FOrdLessThanOp, SPV_GLFClampOp],
+    [SPV_FOrdLessThanEqualOp, SPV_GLFClampOp],
+    [SPV_SLessThanOp, SPV_GLSClampOp],
+    [SPV_SLessThanEqualOp, SPV_GLSClampOp],
+    [SPV_ULessThanOp, SPV_GLUClampOp],
+    [SPV_ULessThanEqualOp, SPV_GLUClampOp]] in {
 
 // Detect: $min < $input, $input < $max
 def ConvertComparisonIntoClamp1_#CmpClampPair[0] : Pat<
     (SPV_SelectOp
         (CmpClampPair[0]
             (SPV_SelectOp:$middle0
                 (CmpClampPair[0] $min, $input),
                 $input,

mlir/lib/Dialect/SPIRV/IR/SPIRVGLCanonicalization.cpp

-//===- SPIRVGLSLCanonicalization.cpp - SPIR-V GLSL canonicalization patterns =//
+//===- SPIRVGLCanonicalization.cpp - SPIR-V GLSL canonicalization patterns =//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the canonicalization patterns for SPIR-V GLSL-specific ops.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Dialect/SPIRV/IR/SPIRVGLSLCanonicalization.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h"
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 
 using namespace mlir;
 
 namespace {
 #include "SPIRVCanonicalization.inc"
 } // namespace
 
 namespace mlir {
 namespace spirv {
-void populateSPIRVGLSLCanonicalizationPatterns(RewritePatternSet &results) {
+void populateSPIRVGLCanonicalizationPatterns(RewritePatternSet &results) {
   results.add<ConvertComparisonIntoClamp1_SPV_FOrdLessThanOp,
               ConvertComparisonIntoClamp1_SPV_FOrdLessThanEqualOp,
               ConvertComparisonIntoClamp1_SPV_SLessThanOp,
               ConvertComparisonIntoClamp1_SPV_SLessThanEqualOp,
               ConvertComparisonIntoClamp1_SPV_ULessThanOp,
               ConvertComparisonIntoClamp1_SPV_ULessThanEqualOp,
               ConvertComparisonIntoClamp2_SPV_FOrdLessThanOp,
               ConvertComparisonIntoClamp2_SPV_FOrdLessThanEqualOp,
               ConvertComparisonIntoClamp2_SPV_SLessThanOp,
               ConvertComparisonIntoClamp2_SPV_SLessThanEqualOp,
               ConvertComparisonIntoClamp2_SPV_ULessThanOp,
               ConvertComparisonIntoClamp2_SPV_ULessThanEqualOp>(
       results.getContext());
 }
 } // namespace spirv
 } // namespace mlir

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

   return (*this)->getAttrOfType<SymbolRefAttr>(kCallee);
 }
 
 Operation::operand_range spirv::FunctionCallOp::getArgOperands() {
   return arguments();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSLFClampOp
+// spv.GLFClampOp
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::GLSLFClampOp::parse(OpAsmParser &parser,
-                                       OperationState &result) {
+ParseResult spirv::GLFClampOp::parse(OpAsmParser &parser,
   return parseOneResultSameOperandTypeOp(parser, result);
 }
-void spirv::GLSLFClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
+void spirv::GLFClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSLUClampOp
+// spv.GLUClampOp
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::GLSLUClampOp::parse(OpAsmParser &parser,
-                                       OperationState &result) {
+ParseResult spirv::GLUClampOp::parse(OpAsmParser &parser,
   return parseOneResultSameOperandTypeOp(parser, result);
 }
-void spirv::GLSLUClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
+void spirv::GLUClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSLSClampOp
+// spv.GLSClampOp
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::GLSLSClampOp::parse(OpAsmParser &parser,
-                                       OperationState &result) {
+ParseResult spirv::GLSClampOp::parse(OpAsmParser &parser,
   return parseOneResultSameOperandTypeOp(parser, result);
 }
-void spirv::GLSLSClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
+void spirv::GLSClampOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSLFmaOp
+// spv.GLFmaOp
 //===----------------------------------------------------------------------===//
 
-ParseResult spirv::GLSLFmaOp::parse(OpAsmParser &parser,
-                                    OperationState &result) {
+ParseResult spirv::GLFmaOp::parse(OpAsmParser &parser, OperationState &result) {
   return parseOneResultSameOperandTypeOp(parser, result);
 }
-void spirv::GLSLFmaOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
+void spirv::GLFmaOp::print(OpAsmPrinter &p) { printOneResultOp(*this, p); }
 
 //===----------------------------------------------------------------------===//
 // spv.GlobalVariable
 //===----------------------------------------------------------------------===//
 
 void spirv::GlobalVariableOp::build(OpBuilder &builder, OperationState &state,
                                     Type type, StringRef name,
                                     unsigned descriptorSet, unsigned binding) {

              spirv::SpecConstantOperationOp>(operand.getDefiningOp()))
       return emitOpError(
           "invalid operand, must be defined by a constant operation");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FrexpStruct
+// spv.GL.FrexpStruct
 //===----------------------------------------------------------------------===//
 
-LogicalResult spirv::GLSLFrexpStructOp::verify() {
+LogicalResult spirv::GLFrexpStructOp::verify() {
   spirv::StructType structTy = result().getType().dyn_cast<spirv::StructType>();
 
   if (structTy.getNumElements() != 2)
     return emitError("result type must be a struct type with two memebers");
 
   Type significandTy = structTy.getElementType(0);
   Type exponentTy = structTy.getElementType(1);
   VectorType exponentVecTy = exponentTy.dyn_cast<VectorType>();

   if (operandFTy && exponentIntTy)
     return success();
 
   return emitError("member one of the resulting struct type must have the same "
                    "number of components as the operand type");
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Ldexp
+// spv.GL.Ldexp
 //===----------------------------------------------------------------------===//
 
-LogicalResult spirv::GLSLLdexpOp::verify() {
+LogicalResult spirv::GLLdexpOp::verify() {
   Type significandType = x().getType();
   Type exponentType = exp().getType();
 
   if (significandType.isa<FloatType>() != exponentType.isa<IntegerType>())
     return emitOpError("operands must both be scalars or vectors");
 
   auto getNumElements = [](Type type) -> unsigned {
     if (auto vectorType = type.dyn_cast<VectorType>())

mlir/lib/Dialect/SPIRV/Transforms/CMakeLists.txt

 set(LLVM_OPTIONAL_SOURCES
-  CanonicalizeGLSLPass.cpp
+  CanonicalizeGLPass.cpp
   DecorateCompositeTypeLayoutPass.cpp
   LowerABIAttributesPass.cpp
   RewriteInsertsPass.cpp
   SPIRVConversion.cpp
   UnifyAliasedResourcePass.cpp
   UpdateVCEPass.cpp
 )
 
 add_mlir_dialect_library(MLIRSPIRVConversion
   SPIRVConversion.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV
 
   LINK_LIBS PUBLIC
   MLIRFuncDialect
   MLIRSPIRVDialect
   MLIRTransformUtils
 )
 
 add_mlir_dialect_library(MLIRSPIRVTransforms
-  CanonicalizeGLSLPass.cpp
+  CanonicalizeGLPass.cpp
   DecorateCompositeTypeLayoutPass.cpp
   LowerABIAttributesPass.cpp
   RewriteInsertsPass.cpp
   UnifyAliasedResourcePass.cpp
   UpdateVCEPass.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/SPIRV

mlir/lib/Dialect/SPIRV/Transforms/CanonicalizeGLPass.cpp

-//===- CanonicalizeGLSLPass.cpp - GLSL Related Canonicalization Pass ------===//
+//===- CanonicalizeGLPass.cpp - GLSL Related Canonicalization Pass ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
-#include "mlir/Dialect/SPIRV/IR/SPIRVGLSLCanonicalization.h"
+#include "mlir/Dialect/SPIRV/IR/SPIRVGLCanonicalization.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Transforms/Passes.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
 
 namespace {
-class CanonicalizeGLSLPass final
-    : public SPIRVCanonicalizeGLSLBase<CanonicalizeGLSLPass> {
+class CanonicalizeGLPass final
+    : public SPIRVCanonicalizeGLBase<CanonicalizeGLPass> {
 public:
   void runOnOperation() override {
     RewritePatternSet patterns(&getContext());
-    spirv::populateSPIRVGLSLCanonicalizationPatterns(patterns);
+    spirv::populateSPIRVGLCanonicalizationPatterns(patterns);
     if (failed(
             applyPatternsAndFoldGreedily(getOperation(), std::move(patterns))))
       return signalPassFailure();
   }
 };
 } // namespace
 
-std::unique_ptr<OperationPass<>> spirv::createCanonicalizeGLSLPass() {
-  return std::make_unique<CanonicalizeGLSLPass>();
+std::unique_ptr<OperationPass<>> spirv::createCanonicalizeGLPass() {
+  return std::make_unique<CanonicalizeGLPass>();
 }

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

func.func @int32_scalar(%lhs: i32, %rhs: i32) {
   // CHECK: spv.UMod %{{.*}}, %{{.*}}: i32
   %5 = arith.remui %lhs, %rhs: i32
   return
 }
 
 // CHECK-LABEL: @int32_scalar_srem
 // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
 func.func @int32_scalar_srem(%lhs: i32, %rhs: i32) {
-  // CHECK: %[[LABS:.+]] = spv.GLSL.SAbs %[[LHS]] : i32
-  // CHECK: %[[RABS:.+]] = spv.GLSL.SAbs %[[RHS]] : i32
+  // CHECK: %[[LABS:.+]] = spv.GL.SAbs %[[LHS]] : i32
+  // CHECK: %[[RABS:.+]] = spv.GL.SAbs %[[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
 }
 
func.func @index_scalar(%lhs: index, %rhs: index) {
   return
 }
 
 // CHECK-LABEL: @index_scalar_srem
 // CHECK-SAME: (%[[A:.+]]: index, %[[B:.+]]: index)
 func.func @index_scalar_srem(%lhs: index, %rhs: index) {
   // CHECK: %[[LHS:.+]] = builtin.unrealized_conversion_cast %[[A]] : index to i32
   // CHECK: %[[RHS:.+]] = builtin.unrealized_conversion_cast %[[B]] : index to i32
-  // CHECK: %[[LABS:.+]] = spv.GLSL.SAbs %[[LHS]] : i32
-  // CHECK: %[[RABS:.+]] = spv.GLSL.SAbs %[[RHS]] : i32
+  // CHECK: %[[LABS:.+]] = spv.GL.SAbs %[[LHS]] : i32
+  // CHECK: %[[RABS:.+]] = spv.GL.SAbs %[[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: index
   return
 }
 
func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
   // CHECK: spv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
   %1 = arith.divui %arg1, %arg1: vector<4xi64>
   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.GLSL.SAbs %[[LHS]] : vector<3xi16>
-  // CHECK: %[[RABS:.+]] = spv.GLSL.SAbs %[[RHS]] : vector<3xi16>
+  // CHECK: %[[LABS:.+]] = spv.GL.SAbs %[[LHS]] : vector<3xi16>
+  // CHECK: %[[RABS:.+]] = spv.GL.SAbs %[[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
 }
 
func.func @int32_scalar(%lhs: i32, %rhs: i32) {
   // CHECK: spv.IMul %{{.*}}, %{{.*}}: i32
   %2 = arith.muli %lhs, %rhs: i32
   // CHECK: spv.SDiv %{{.*}}, %{{.*}}: i32
   %3 = arith.divsi %lhs, %rhs: i32
   // CHECK: spv.UDiv %{{.*}}, %{{.*}}: i32
   %4 = arith.divui %lhs, %rhs: i32
   // CHECK: spv.UMod %{{.*}}, %{{.*}}: i32
   %5 = arith.remui %lhs, %rhs: i32
-  // CHECK: spv.GLSL.SMax %{{.*}}, %{{.*}}: i32
+  // CHECK: spv.GL.SMax %{{.*}}, %{{.*}}: i32
   %6 = arith.maxsi %lhs, %rhs : i32
-  // CHECK: spv.GLSL.UMax %{{.*}}, %{{.*}}: i32
+  // CHECK: spv.GL.UMax %{{.*}}, %{{.*}}: i32
   %7 = arith.maxui %lhs, %rhs : i32
-  // CHECK: spv.GLSL.SMin %{{.*}}, %{{.*}}: i32
+  // CHECK: spv.GL.SMin %{{.*}}, %{{.*}}: i32
   %8 = arith.minsi %lhs, %rhs : i32
-  // CHECK: spv.GLSL.UMin %{{.*}}, %{{.*}}: i32
+  // CHECK: spv.GL.UMin %{{.*}}, %{{.*}}: i32
   %9 = arith.minui %lhs, %rhs : i32
   return
 }
 
 // CHECK-LABEL: @scalar_srem
 // CHECK-SAME: (%[[LHS:.+]]: i32, %[[RHS:.+]]: i32)
 func.func @scalar_srem(%lhs: i32, %rhs: i32) {
-  // CHECK: %[[LABS:.+]] = spv.GLSL.SAbs %[[LHS]] : i32
-  // CHECK: %[[RABS:.+]] = spv.GLSL.SAbs %[[RHS]] : i32
+  // CHECK: %[[LABS:.+]] = spv.GL.SAbs %[[LHS]] : i32
+  // CHECK: %[[RABS:.+]] = spv.GL.SAbs %[[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
 }
 
func.func @float32_binary_scalar(%lhs: f32, %rhs: f32) {
   // CHECK: spv.FSub %{{.*}}, %{{.*}}: f32
   %1 = arith.subf %lhs, %rhs: f32
   // CHECK: spv.FMul %{{.*}}, %{{.*}}: f32
   %2 = arith.mulf %lhs, %rhs: f32
   // CHECK: spv.FDiv %{{.*}}, %{{.*}}: f32
   %3 = arith.divf %lhs, %rhs: f32
   // CHECK: spv.FRem %{{.*}}, %{{.*}}: f32
   %4 = arith.remf %lhs, %rhs: f32
-  // CHECK: spv.GLSL.FMax %{{.*}}, %{{.*}}: f32
+  // CHECK: spv.GL.FMax %{{.*}}, %{{.*}}: f32
   %5 = arith.maxf %lhs, %rhs: f32
-  // CHECK: spv.GLSL.FMin %{{.*}}, %{{.*}}: f32
+  // CHECK: spv.GL.FMin %{{.*}}, %{{.*}}: f32
   %6 = arith.minf %lhs, %rhs: f32
   return
 }
 
 // Check int vector types.
 // CHECK-LABEL: @int_vector234
 func.func @int_vector234(%arg0: vector<2xi8>, %arg1: vector<4xi64>) {
   // CHECK: spv.SDiv %{{.*}}, %{{.*}}: vector<2xi8>
   %0 = arith.divsi %arg0, %arg0: vector<2xi8>
   // CHECK: spv.UDiv %{{.*}}, %{{.*}}: vector<4xi64>
   %1 = arith.divui %arg1, %arg1: vector<4xi64>
   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.GLSL.SAbs %[[LHS]] : vector<3xi16>
-  // CHECK: %[[RABS:.+]] = spv.GLSL.SAbs %[[RHS]] : vector<3xi16>
+  // CHECK: %[[LABS:.+]] = spv.GL.SAbs %[[LHS]] : vector<3xi16>
+  // CHECK: %[[RABS:.+]] = spv.GL.SAbs %[[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-gl-spirv.mlir

 // RUN: mlir-opt -split-input-file -convert-math-to-spirv -verify-diagnostics %s -o - | FileCheck %s
 
 module attributes {
   spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], []>, #spv.resource_limits<>>
 } {
 
 // CHECK-LABEL: @float32_unary_scalar
 func.func @float32_unary_scalar(%arg0: f32) {
-  // CHECK: spv.GLSL.Cos %{{.*}}: f32
+  // CHECK: spv.GL.Cos %{{.*}}: f32
   %0 = math.cos %arg0 : f32
-  // CHECK: spv.GLSL.Exp %{{.*}}: f32
+  // CHECK: spv.GL.Exp %{{.*}}: f32
   %1 = math.exp %arg0 : f32
-  // CHECK: %[[EXP:.+]] = spv.GLSL.Exp %arg0
+  // CHECK: %[[EXP:.+]] = spv.GL.Exp %arg0
   // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
   // CHECK: spv.FSub %[[EXP]], %[[ONE]]
   %2 = math.expm1 %arg0 : f32
-  // CHECK: spv.GLSL.Log %{{.*}}: f32
+  // CHECK: spv.GL.Log %{{.*}}: f32
   %3 = math.log %arg0 : f32
   // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00 : f32
   // CHECK: %[[ADDONE:.+]] = spv.FAdd %[[ONE]], %{{.+}}
-  // CHECK: spv.GLSL.Log %[[ADDONE]]
+  // CHECK: spv.GL.Log %[[ADDONE]]
   %4 = math.log1p %arg0 : f32
-  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: f32
+  // CHECK: spv.GL.InverseSqrt %{{.*}}: f32
   %5 = math.rsqrt %arg0 : f32
-  // CHECK: spv.GLSL.Sqrt %{{.*}}: f32
+  // CHECK: spv.GL.Sqrt %{{.*}}: f32
   %6 = math.sqrt %arg0 : f32
-  // CHECK: spv.GLSL.Tanh %{{.*}}: f32
+  // CHECK: spv.GL.Tanh %{{.*}}: f32
   %7 = math.tanh %arg0 : f32
-  // CHECK: spv.GLSL.Sin %{{.*}}: f32
+  // CHECK: spv.GL.Sin %{{.*}}: f32
   %8 = math.sin %arg0 : f32
-  // CHECK: spv.GLSL.FAbs %{{.*}}: f32
+  // CHECK: spv.GL.FAbs %{{.*}}: f32
   %9 = math.abs %arg0 : f32
-  // CHECK: spv.GLSL.Ceil %{{.*}}: f32
+  // CHECK: spv.GL.Ceil %{{.*}}: f32
   %10 = math.ceil %arg0 : f32
-  // CHECK: spv.GLSL.Floor %{{.*}}: f32
+  // CHECK: spv.GL.Floor %{{.*}}: f32
   %11 = math.floor %arg0 : f32
   return
 }
 
 // CHECK-LABEL: @float32_unary_vector
 func.func @float32_unary_vector(%arg0: vector<3xf32>) {
-  // CHECK: spv.GLSL.Cos %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.Cos %{{.*}}: vector<3xf32>
   %0 = math.cos %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Exp %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.Exp %{{.*}}: vector<3xf32>
   %1 = math.exp %arg0 : vector<3xf32>
-  // CHECK: %[[EXP:.+]] = spv.GLSL.Exp %arg0
+  // CHECK: %[[EXP:.+]] = spv.GL.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.GLSL.Log %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.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.GLSL.Log %[[ADDONE]]
+  // CHECK: spv.GL.Log %[[ADDONE]]
   %4 = math.log1p %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.InverseSqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.InverseSqrt %{{.*}}: vector<3xf32>
   %5 = math.rsqrt %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Sqrt %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.Sqrt %{{.*}}: vector<3xf32>
   %6 = math.sqrt %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Tanh %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.Tanh %{{.*}}: vector<3xf32>
   %7 = math.tanh %arg0 : vector<3xf32>
-  // CHECK: spv.GLSL.Sin %{{.*}}: vector<3xf32>
+  // CHECK: spv.GL.Sin %{{.*}}: vector<3xf32>
   %8 = math.sin %arg0 : vector<3xf32>
   return
 }
 
 // CHECK-LABEL: @float32_ternary_scalar
 func.func @float32_ternary_scalar(%a: f32, %b: f32, %c: f32) {
-  // CHECK: spv.GLSL.Fma %{{.*}}: f32
+  // CHECK: spv.GL.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.GLSL.Fma %{{.*}}: vector<4xf32>
+  // CHECK: spv.GL.Fma %{{.*}}: vector<4xf32>
   %0 = math.fma %a, %b, %c : vector<4xf32>
   return
 }
 
 // CHECK-LABEL: @ctlz_scalar
 //  CHECK-SAME: (%[[VAL:.+]]: i32)
 func.func @ctlz_scalar(%val: i32) -> i32 {
   // CHECK-DAG: %[[V1:.+]] = spv.Constant 1 : i32
   // CHECK-DAG: %[[V31:.+]] = spv.Constant 31 : i32
   // CHECK-DAG: %[[V32:.+]] = spv.Constant 32 : i32
-  // CHECK: %[[MSB:.+]] = spv.GLSL.FindUMsb %[[VAL]] : i32
+  // CHECK: %[[MSB:.+]] = spv.GL.FindUMsb %[[VAL]] : i32
   // CHECK: %[[SUB1:.+]] = spv.ISub %[[V31]], %[[MSB]] : i32
   // CHECK: %[[SUB2:.+]] = spv.ISub %[[V32]], %[[VAL]] : i32
   // CHECK: %[[CMP:.+]] = spv.ULessThanEqual %[[VAL]], %[[V1]] : i32
   // CHECK: %[[R:.+]] = spv.Select %[[CMP]], %[[SUB2]], %[[SUB1]] : i1, i32
   // CHECK: return %[[R]]
   %0 = math.ctlz %val : i32
   return %0 : i32
 }
 
 // CHECK-LABEL: @ctlz_vector1
 func.func @ctlz_vector1(%val: vector<1xi32>) -> vector<1xi32> {
-  // CHECK: spv.GLSL.FindUMsb
+  // CHECK: spv.GL.FindUMsb
   // CHECK: spv.ISub
   // CHECK: spv.ULessThanEqual
   // CHECK: spv.Select
   %0 = math.ctlz %val : vector<1xi32>
   return %0 : vector<1xi32>
 }
 
 // CHECK-LABEL: @ctlz_vector2
 //  CHECK-SAME: (%[[VAL:.+]]: vector<2xi32>)
 func.func @ctlz_vector2(%val: vector<2xi32>) -> vector<2xi32> {
   // CHECK-DAG: %[[V1:.+]] = spv.Constant dense<1> : vector<2xi32>
   // CHECK-DAG: %[[V31:.+]] = spv.Constant dense<31> : vector<2xi32>
   // CHECK-DAG: %[[V32:.+]] = spv.Constant dense<32> : vector<2xi32>
-  // CHECK: %[[MSB:.+]] = spv.GLSL.FindUMsb %[[VAL]] : vector<2xi32>
+  // CHECK: %[[MSB:.+]] = spv.GL.FindUMsb %[[VAL]] : vector<2xi32>
   // CHECK: %[[SUB1:.+]] = spv.ISub %[[V31]], %[[MSB]] : vector<2xi32>
   // CHECK: %[[SUB2:.+]] = spv.ISub %[[V32]], %[[VAL]] : vector<2xi32>
   // CHECK: %[[CMP:.+]] = spv.ULessThanEqual %[[VAL]], %[[V1]] : vector<2xi32>
   // CHECK: %[[R:.+]] = spv.Select %[[CMP]], %[[SUB2]], %[[SUB1]] : vector<2xi1>, vector<2xi32>
   %0 = math.ctlz %val : vector<2xi32>
   return %0 : vector<2xi32>
 }
 
 // CHECK-LABEL: @powf_scalar
 //  CHECK-SAME: (%[[LHS:.+]]: f32, %[[RHS:.+]]: f32)
 func.func @powf_scalar(%lhs: f32, %rhs: f32) -> f32 {
   // CHECK: %[[F0:.+]] = spv.Constant 0.000000e+00 : f32
   // CHECK: %[[LT:.+]] = spv.FOrdLessThan %[[LHS]], %[[F0]] : f32
-  // CHECK: %[[ABS:.+]] = spv.GLSL.FAbs %[[LHS]] : f32
-  // CHECK: %[[POW:.+]] = spv.GLSL.Pow %[[ABS]], %[[RHS]] : f32
+  // CHECK: %[[ABS:.+]] = spv.GL.FAbs %[[LHS]] : f32
+  // CHECK: %[[POW:.+]] = spv.GL.Pow %[[ABS]], %[[RHS]] : f32
   // CHECK: %[[NEG:.+]] = spv.FNegate %[[POW]] : f32
   // CHECK: %[[SEL:.+]] = spv.Select %[[LT]], %[[NEG]], %[[POW]] : i1, f32
   %0 = math.powf %lhs, %rhs : f32
   // CHECK: return %[[SEL]]
   return %0: f32
 }
 
 // CHECK-LABEL: @powf_vector
 func.func @powf_vector(%lhs: vector<4xf32>, %rhs: vector<4xf32>) -> vector<4xf32> {
   // CHECK: spv.FOrdLessThan
-  // CHEKC: spv.GLSL.FAbs
-  // CHECK: spv.GLSL.Pow %{{.*}}: vector<4xf32>
+  // CHEKC: spv.GL.FAbs
+  // CHECK: spv.GL.Pow %{{.*}}: vector<4xf32>
   // CHECK: spv.FNegate
   // CHECK: spv.Select
   %0 = math.powf %lhs, %rhs : vector<4xf32>
   return %0: vector<4xf32>
 }
 
 // CHECK-LABEL: @round_scalar
 func.func @round_scalar(%x: f32) -> f32 {
   // CHECK: %[[ZERO:.+]] = spv.Constant 0.000000e+00
   // CHECK: %[[ONE:.+]] = spv.Constant 1.000000e+00
   // CHECK: %[[HALF:.+]] = spv.Constant 5.000000e-01
-  // CHECK: %[[ABS:.+]] = spv.GLSL.FAbs %arg0
-  // CHECK: %[[FLOOR:.+]] = spv.GLSL.Floor %[[ABS]]
+  // CHECK: %[[ABS:.+]] = spv.GL.FAbs %arg0
+  // CHECK: %[[FLOOR:.+]] = spv.GL.Floor %[[ABS]]
   // CHECK: %[[SUB:.+]] = spv.FSub %[[ABS]], %[[FLOOR]]
   // CHECK: %[[GE:.+]] = spv.FOrdGreaterThanEqual %[[SUB]], %[[HALF]]
   // CHECK: %[[SEL:.+]] = spv.Select %[[GE]], %[[ONE]], %[[ZERO]]
   // CHECK: %[[ADD:.+]] = spv.FAdd %[[FLOOR]], %[[SEL]]
   // CHECK: %[[BITCAST:.+]] = spv.Bitcast %[[ADD]]
   %0 = math.round %x : f32
   return %0: f32
 }
 
 // CHECK-LABEL: @round_vector
 func.func @round_vector(%x: vector<4xf32>) -> vector<4xf32> {
   // CHECK: %[[ZERO:.+]] = spv.Constant dense<0.000000e+00>
   // CHECK: %[[ONE:.+]] = spv.Constant dense<1.000000e+00>
   // CHECK: %[[HALF:.+]] = spv.Constant dense<5.000000e-01>
-  // CHECK: %[[ABS:.+]] = spv.GLSL.FAbs %arg0
-  // CHECK: %[[FLOOR:.+]] = spv.GLSL.Floor %[[ABS]]
+  // CHECK: %[[ABS:.+]] = spv.GL.FAbs %arg0
+  // CHECK: %[[FLOOR:.+]] = spv.GL.Floor %[[ABS]]
   // CHECK: %[[SUB:.+]] = spv.FSub %[[ABS]], %[[FLOOR]]
   // CHECK: %[[GE:.+]] = spv.FOrdGreaterThanEqual %[[SUB]], %[[HALF]]
   // CHECK: %[[SEL:.+]] = spv.Select %[[GE]], %[[ONE]], %[[ZERO]]
   // CHECK: %[[ADD:.+]] = spv.FAdd %[[FLOOR]], %[[SEL]]
   // CHECK: %[[BITCAST:.+]] = spv.Bitcast %[[ADD]]
   %0 = math.round %x : vector<4xf32>
   return %0: vector<4xf32>
 }

mlir/test/Conversion/SPIRVToLLVM/gl-ops-to-llvm.mlir

 // RUN: mlir-opt -convert-spirv-to-llvm %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Ceil
+// spv.GL.Ceil
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @ceil
 spv.func @ceil(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.ceil"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Ceil %arg0 : f32
+  %0 = spv.GL.Ceil %arg0 : f32
   // CHECK: "llvm.intr.ceil"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Ceil %arg1 : vector<3xf16>
+  %1 = spv.GL.Ceil %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Cos
+// spv.GL.Cos
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @cos
 spv.func @cos(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.cos"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Cos %arg0 : f32
+  %0 = spv.GL.Cos %arg0 : f32
   // CHECK: "llvm.intr.cos"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Cos %arg1 : vector<3xf16>
+  %1 = spv.GL.Cos %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Exp
+// spv.GL.Exp
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @exp
 spv.func @exp(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.exp"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Exp %arg0 : f32
+  %0 = spv.GL.Exp %arg0 : f32
   // CHECK: "llvm.intr.exp"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Exp %arg1 : vector<3xf16>
+  %1 = spv.GL.Exp %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FAbs
+// spv.GL.FAbs
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @fabs
 spv.func @fabs(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.fabs"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.FAbs %arg0 : f32
+  %0 = spv.GL.FAbs %arg0 : f32
   // CHECK: "llvm.intr.fabs"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.FAbs %arg1 : vector<3xf16>
+  %1 = spv.GL.FAbs %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Floor
+// spv.GL.Floor
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @floor
 spv.func @floor(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.floor"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Floor %arg0 : f32
+  %0 = spv.GL.Floor %arg0 : f32
   // CHECK: "llvm.intr.floor"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Floor %arg1 : vector<3xf16>
+  %1 = spv.GL.Floor %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FMax
+// spv.GL.FMax
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @fmax
 spv.func @fmax(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.maxnum"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
-  %0 = spv.GLSL.FMax %arg0, %arg0 : f32
+  %0 = spv.GL.FMax %arg0, %arg0 : f32
   // CHECK: "llvm.intr.maxnum"(%{{.*}}, %{{.*}}) : (vector<3xf16>, vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.FMax %arg1, %arg1 : vector<3xf16>
+  %1 = spv.GL.FMax %arg1, %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FMin
+// spv.GL.FMin
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @fmin
 spv.func @fmin(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.minnum"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
-  %0 = spv.GLSL.FMin %arg0, %arg0 : f32
+  %0 = spv.GL.FMin %arg0, %arg0 : f32
   // CHECK: "llvm.intr.minnum"(%{{.*}}, %{{.*}}) : (vector<3xf16>, vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.FMin %arg1, %arg1 : vector<3xf16>
+  %1 = spv.GL.FMin %arg1, %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Log
+// spv.GL.Log
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @log
 spv.func @log(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.log"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Log %arg0 : f32
+  %0 = spv.GL.Log %arg0 : f32
   // CHECK: "llvm.intr.log"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Log %arg1 : vector<3xf16>
+  %1 = spv.GL.Log %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Sin
+// spv.GL.Sin
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @sin
 spv.func @sin(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.sin"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Sin %arg0 : f32
+  %0 = spv.GL.Sin %arg0 : f32
   // CHECK: "llvm.intr.sin"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Sin %arg1 : vector<3xf16>
+  %1 = spv.GL.Sin %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.SMax
+// spv.GL.SMax
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @smax
 spv.func @smax(%arg0: i16, %arg1: vector<3xi32>) "None" {
   // CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (i16, i16) -> i16
-  %0 = spv.GLSL.SMax %arg0, %arg0 : i16
+  %0 = spv.GL.SMax %arg0, %arg0 : i16
   // CHECK: "llvm.intr.smax"(%{{.*}}, %{{.*}}) : (vector<3xi32>, vector<3xi32>) -> vector<3xi32>
-  %1 = spv.GLSL.SMax %arg1, %arg1 : vector<3xi32>
+  %1 = spv.GL.SMax %arg1, %arg1 : vector<3xi32>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.SMin
+// spv.GL.SMin
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @smin
 spv.func @smin(%arg0: i16, %arg1: vector<3xi32>) "None" {
   // CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (i16, i16) -> i16
-  %0 = spv.GLSL.SMin %arg0, %arg0 : i16
+  %0 = spv.GL.SMin %arg0, %arg0 : i16
   // CHECK: "llvm.intr.smin"(%{{.*}}, %{{.*}}) : (vector<3xi32>, vector<3xi32>) -> vector<3xi32>
-  %1 = spv.GLSL.SMin %arg1, %arg1 : vector<3xi32>
+  %1 = spv.GL.SMin %arg1, %arg1 : vector<3xi32>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Sqrt
+// spv.GL.Sqrt
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @sqrt
 spv.func @sqrt(%arg0: f32, %arg1: vector<3xf16>) "None" {
   // CHECK: "llvm.intr.sqrt"(%{{.*}}) : (f32) -> f32
-  %0 = spv.GLSL.Sqrt %arg0 : f32
+  %0 = spv.GL.Sqrt %arg0 : f32
   // CHECK: "llvm.intr.sqrt"(%{{.*}}) : (vector<3xf16>) -> vector<3xf16>
-  %1 = spv.GLSL.Sqrt %arg1 : vector<3xf16>
+  %1 = spv.GL.Sqrt %arg1 : vector<3xf16>
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Tan
+// spv.GL.Tan
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @tan
 spv.func @tan(%arg0: f32) "None" {
   // CHECK: %[[SIN:.*]] = "llvm.intr.sin"(%{{.*}}) : (f32) -> f32
   // CHECK: %[[COS:.*]] = "llvm.intr.cos"(%{{.*}}) : (f32) -> f32
   // CHECK: llvm.fdiv %[[SIN]], %[[COS]] : f32
-  %0 = spv.GLSL.Tan %arg0 : f32
+  %0 = spv.GL.Tan %arg0 : f32
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Tanh
+// spv.GL.Tanh
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @tanh
 spv.func @tanh(%arg0: f32) "None" {
   // CHECK: %[[TWO:.*]] = llvm.mlir.constant(2.000000e+00 : f32) : f32
   // CHECK: %[[X2:.*]] = llvm.fmul %[[TWO]], %{{.*}} : f32
   // CHECK: %[[EXP:.*]] = "llvm.intr.exp"(%[[X2]]) : (f32) -> f32
   // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
   // CHECK: %[[T0:.*]] = llvm.fsub %[[EXP]], %[[ONE]] : f32
   // CHECK: %[[T1:.*]] = llvm.fadd %[[EXP]], %[[ONE]] : f32
   // CHECK: llvm.fdiv %[[T0]], %[[T1]] : f32
-  %0 = spv.GLSL.Tanh %arg0 : f32
+  %0 = spv.GL.Tanh %arg0 : f32
   spv.Return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.InverseSqrt
+// spv.GL.InverseSqrt
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: @inverse_sqrt
 spv.func @inverse_sqrt(%arg0: f32) "None" {
   // CHECK: %[[ONE:.*]] = llvm.mlir.constant(1.000000e+00 : f32) : f32
   // CHECK: %[[SQRT:.*]] = "llvm.intr.sqrt"(%{{.*}}) : (f32) -> f32
   // CHECK: llvm.fdiv %[[ONE]], %[[SQRT]] : f32
-  %0 = spv.GLSL.InverseSqrt %arg0 : f32
+  %0 = spv.GL.InverseSqrt %arg0 : f32
   spv.Return
 }

mlir/test/Conversion/VectorToSPIRV/vector-to-spirv.mlir

func.func @insert_size1_vector(%arg0 : vector<1xf32>, %arg1: vector<3xf32>) -> vector<3xf32> {
   %1 = vector.insert_strided_slice %arg0, %arg1 {offsets = [2], strides = [1]} : vector<1xf32> into vector<3xf32>
   return %1 : vector<3xf32>
 }
 
 // -----
 
 // CHECK-LABEL: @fma
 //  CHECK-SAME: %[[A:.*]]: vector<4xf32>, %[[B:.*]]: vector<4xf32>, %[[C:.*]]: vector<4xf32>
-//       CHECK:   spv.GLSL.Fma %[[A]], %[[B]], %[[C]] : vector<4xf32>
+//       CHECK:   spv.GL.Fma %[[A]], %[[B]], %[[C]] : vector<4xf32>
 func.func @fma(%a: vector<4xf32>, %b: vector<4xf32>, %c: vector<4xf32>) -> vector<4xf32> {
   %0 = vector.fma %a, %b, %c: vector<4xf32>
   return %0 : vector<4xf32>
 }
 
 // -----
 
 // CHECK-LABEL: @fma_size1_vector
-//       CHECK:   spv.GLSL.Fma %{{.+}} : f32
+//       CHECK:   spv.GL.Fma %{{.+}} : f32
 func.func @fma_size1_vector(%a: vector<1xf32>, %b: vector<1xf32>, %c: vector<1xf32>) -> vector<1xf32> {
   %0 = vector.fma %a, %b, %c: vector<1xf32>
   return %0 : vector<1xf32>
 }
 
 // -----
 
 // CHECK-LABEL: func @splat

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

 // RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Exp
+// spv.GL.Exp
 //===----------------------------------------------------------------------===//
 
 func.func @exp(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Exp {{%.*}} : f32
-  %2 = spv.GLSL.Exp %arg0 : f32
+  // CHECK: spv.GL.Exp {{%.*}} : f32
+  %2 = spv.GL.Exp %arg0 : f32
   return
 }
 
 func.func @expvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Exp {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Exp %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Exp {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Exp %arg0 : vector<3xf16>
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values}}
-  %2 = spv.GLSL.Exp %arg0 : i32
+  %2 = spv.GL.Exp %arg0 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : vector<5xf32>) -> () {
   // expected-error @+1 {{op operand #0 must be 16/32-bit float or vector of 16/32-bit float values of length 2/3/4}}
-  %2 = spv.GLSL.Exp %arg0 : vector<5xf32>
+  %2 = spv.GL.Exp %arg0 : vector<5xf32>
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : f32, %arg1 : f32) -> () {
   // expected-error @+1 {{expected ':'}}
-  %2 = spv.GLSL.Exp %arg0, %arg1 : i32
+  %2 = spv.GL.Exp %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 func.func @exp(%arg0 : i32) -> () {
   // expected-error @+1 {{expected non-function type}}
-  %2 = spv.GLSL.Exp %arg0 :
+  %2 = spv.GL.Exp %arg0 :
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.{F|S|U}{Max|Min}
+// spv.GL.{F|S|U}{Max|Min}
 //===----------------------------------------------------------------------===//
 
 func.func @fmaxmin(%arg0 : f32, %arg1 : f32) {
-  // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f32
-  %1 = spv.GLSL.FMax %arg0, %arg1 : f32
-  // CHECK: spv.GLSL.FMin {{%.*}}, {{%.*}} : f32
-  %2 = spv.GLSL.FMin %arg0, %arg1 : f32
+  // CHECK: spv.GL.FMax {{%.*}}, {{%.*}} : f32
+  %1 = spv.GL.FMax %arg0, %arg1 : f32
+  // CHECK: spv.GL.FMin {{%.*}}, {{%.*}} : f32
+  %2 = spv.GL.FMin %arg0, %arg1 : f32
   return
 }
 
 func.func @fmaxminvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) {
-  // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : vector<3xf16>
-  %1 = spv.GLSL.FMax %arg0, %arg1 : vector<3xf16>
-  // CHECK: spv.GLSL.FMin {{%.*}}, {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.FMin %arg0, %arg1 : vector<3xf16>
+  // CHECK: spv.GL.FMax {{%.*}}, {{%.*}} : vector<3xf16>
+  %1 = spv.GL.FMax %arg0, %arg1 : vector<3xf16>
+  // CHECK: spv.GL.FMin {{%.*}}, {{%.*}} : vector<3xf16>
+  %2 = spv.GL.FMin %arg0, %arg1 : vector<3xf16>
   return
 }
 
 func.func @fmaxminf64(%arg0 : f64, %arg1 : f64) {
-  // CHECK: spv.GLSL.FMax {{%.*}}, {{%.*}} : f64
-  %1 = spv.GLSL.FMax %arg0, %arg1 : f64
-  // CHECK: spv.GLSL.FMin {{%.*}}, {{%.*}} : f64
-  %2 = spv.GLSL.FMin %arg0, %arg1 : f64
+  // CHECK: spv.GL.FMax {{%.*}}, {{%.*}} : f64
+  %1 = spv.GL.FMax %arg0, %arg1 : f64
+  // CHECK: spv.GL.FMin {{%.*}}, {{%.*}} : f64
+  %2 = spv.GL.FMin %arg0, %arg1 : f64
   return
 }
 
 func.func @iminmax(%arg0: i32, %arg1: i32) {
-  // CHECK: spv.GLSL.SMax {{%.*}}, {{%.*}} : i32
-  %1 = spv.GLSL.SMax %arg0, %arg1 : i32
-  // CHECK: spv.GLSL.UMax {{%.*}}, {{%.*}} : i32
-  %2 = spv.GLSL.UMax %arg0, %arg1 : i32
-  // CHECK: spv.GLSL.SMin {{%.*}}, {{%.*}} : i32
-  %3 = spv.GLSL.SMin %arg0, %arg1 : i32
-  // CHECK: spv.GLSL.UMin {{%.*}}, {{%.*}} : i32
-  %4 = spv.GLSL.UMin %arg0, %arg1 : i32
+  // CHECK: spv.GL.SMax {{%.*}}, {{%.*}} : i32
+  %1 = spv.GL.SMax %arg0, %arg1 : i32
+  // CHECK: spv.GL.UMax {{%.*}}, {{%.*}} : i32
+  %2 = spv.GL.UMax %arg0, %arg1 : i32
+  // CHECK: spv.GL.SMin {{%.*}}, {{%.*}} : i32
+  %3 = spv.GL.SMin %arg0, %arg1 : i32
+  // CHECK: spv.GL.UMin {{%.*}}, {{%.*}} : i32
+  %4 = spv.GL.UMin %arg0, %arg1 : i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.InverseSqrt
+// spv.GL.InverseSqrt
 //===----------------------------------------------------------------------===//
 
 func.func @inversesqrt(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.InverseSqrt {{%.*}} : f32
-  %2 = spv.GLSL.InverseSqrt %arg0 : f32
+  // CHECK: spv.GL.InverseSqrt {{%.*}} : f32
+  %2 = spv.GL.InverseSqrt %arg0 : f32
   return
 }
 
 func.func @inversesqrtvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.InverseSqrt {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.InverseSqrt %arg0 : vector<3xf16>
+  // CHECK: spv.GL.InverseSqrt {{%.*}} : vector<3xf16>
+  %2 = spv.GL.InverseSqrt %arg0 : vector<3xf16>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Sqrt
+// spv.GL.Sqrt
 //===----------------------------------------------------------------------===//
 
 func.func @sqrt(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Sqrt {{%.*}} : f32
-  %2 = spv.GLSL.Sqrt %arg0 : f32
+  // CHECK: spv.GL.Sqrt {{%.*}} : f32
+  %2 = spv.GL.Sqrt %arg0 : f32
   return
 }
 
 func.func @sqrtvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Sqrt {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Sqrt %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Sqrt {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Sqrt %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Cos
+// spv.GL.Cos
 //===----------------------------------------------------------------------===//
 
 func.func @cos(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Cos {{%.*}} : f32
-  %2 = spv.GLSL.Cos %arg0 : f32
+  // CHECK: spv.GL.Cos {{%.*}} : f32
+  %2 = spv.GL.Cos %arg0 : f32
   return
 }
 
 func.func @cosvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Cos {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Cos %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Cos {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Cos %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Sin
+// spv.GL.Sin
 //===----------------------------------------------------------------------===//
 
 func.func @sin(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Sin {{%.*}} : f32
-  %2 = spv.GLSL.Sin %arg0 : f32
+  // CHECK: spv.GL.Sin {{%.*}} : f32
+  %2 = spv.GL.Sin %arg0 : f32
   return
 }
 
 func.func @sinvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Sin {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Sin %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Sin {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Sin %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Tan
+// spv.GL.Tan
 //===----------------------------------------------------------------------===//
 
 func.func @tan(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Tan {{%.*}} : f32
-  %2 = spv.GLSL.Tan %arg0 : f32
+  // CHECK: spv.GL.Tan {{%.*}} : f32
+  %2 = spv.GL.Tan %arg0 : f32
   return
 }
 
 func.func @tanvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Tan {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Tan %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Tan {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Tan %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Acos
+// spv.GL.Acos
 //===----------------------------------------------------------------------===//
 
 func.func @acos(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Acos {{%.*}} : f32
-  %2 = spv.GLSL.Acos %arg0 : f32
+  // CHECK: spv.GL.Acos {{%.*}} : f32
+  %2 = spv.GL.Acos %arg0 : f32
   return
 }
 
 func.func @acosvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Acos {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Acos %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Acos {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Acos %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Asin
+// spv.GL.Asin
 //===----------------------------------------------------------------------===//
 
 func.func @asin(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Asin {{%.*}} : f32
-  %2 = spv.GLSL.Asin %arg0 : f32
+  // CHECK: spv.GL.Asin {{%.*}} : f32
+  %2 = spv.GL.Asin %arg0 : f32
   return
 }
 
 func.func @asinvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Asin {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Asin %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Asin {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Asin %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Atan
+// spv.GL.Atan
 //===----------------------------------------------------------------------===//
 
 func.func @atan(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Atan {{%.*}} : f32
-  %2 = spv.GLSL.Atan %arg0 : f32
+  // CHECK: spv.GL.Atan {{%.*}} : f32
+  %2 = spv.GL.Atan %arg0 : f32
   return
 }
 
 func.func @atanvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Atan {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Atan %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Atan {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Atan %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Sinh
+// spv.GL.Sinh
 //===----------------------------------------------------------------------===//
 
 func.func @sinh(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Sinh {{%.*}} : f32
-  %2 = spv.GLSL.Sinh %arg0 : f32
+  // CHECK: spv.GL.Sinh {{%.*}} : f32
+  %2 = spv.GL.Sinh %arg0 : f32
   return
 }
 
 func.func @sinhvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Sinh {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Sinh %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Sinh {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Sinh %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Cosh
+// spv.GL.Cosh
 //===----------------------------------------------------------------------===//
 
 func.func @cosh(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Cosh {{%.*}} : f32
-  %2 = spv.GLSL.Cosh %arg0 : f32
+  // CHECK: spv.GL.Cosh {{%.*}} : f32
+  %2 = spv.GL.Cosh %arg0 : f32
   return
 }
 
 func.func @coshvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Cosh {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Cosh %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Cosh {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Cosh %arg0 : vector<3xf16>
   return
 }
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Pow
+// spv.GL.Pow
 //===----------------------------------------------------------------------===//
 
 func.func @pow(%arg0 : f32, %arg1 : f32) -> () {
-  // CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : f32
-  %2 = spv.GLSL.Pow %arg0, %arg1 : f32
+  // CHECK: spv.GL.Pow {{%.*}}, {{%.*}} : f32
+  %2 = spv.GL.Pow %arg0, %arg1 : f32
   return
 }
 
 func.func @powvec(%arg0 : vector<3xf16>, %arg1 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Pow {{%.*}}, {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Pow %arg0, %arg1 : vector<3xf16>
+  // CHECK: spv.GL.Pow {{%.*}}, {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Pow %arg0, %arg1 : vector<3xf16>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Round
+// spv.GL.Round
 //===----------------------------------------------------------------------===//
 
 func.func @round(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.Round {{%.*}} : f32
-  %2 = spv.GLSL.Round %arg0 : f32
+  // CHECK: spv.GL.Round {{%.*}} : f32
+  %2 = spv.GL.Round %arg0 : f32
   return
 }
 
 func.func @roundvec(%arg0 : vector<3xf16>) -> () {
-  // CHECK: spv.GLSL.Round {{%.*}} : vector<3xf16>
-  %2 = spv.GLSL.Round %arg0 : vector<3xf16>
+  // CHECK: spv.GL.Round {{%.*}} : vector<3xf16>
+  %2 = spv.GL.Round %arg0 : vector<3xf16>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FClamp
+// spv.GL.FClamp
 //===----------------------------------------------------------------------===//
 
 func.func @fclamp(%arg0 : f32, %min : f32, %max : f32) -> () {
-  // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-  %2 = spv.GLSL.FClamp %arg0, %min, %max : f32
+  // CHECK: spv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+  %2 = spv.GL.FClamp %arg0, %min, %max : f32
   return
 }
 
 // -----
 
 func.func @fclamp(%arg0 : vector<3xf32>, %min : vector<3xf32>, %max : vector<3xf32>) -> () {
-  // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
-  %2 = spv.GLSL.FClamp %arg0, %min, %max : vector<3xf32>
+  // CHECK: spv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
+  %2 = spv.GL.FClamp %arg0, %min, %max : vector<3xf32>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.UClamp
+// spv.GL.UClamp
 //===----------------------------------------------------------------------===//
 
 func.func @uclamp(%arg0 : ui32, %min : ui32, %max : ui32) -> () {
-  // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32
-  %2 = spv.GLSL.UClamp %arg0, %min, %max : ui32
+  // CHECK: spv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : ui32
+  %2 = spv.GL.UClamp %arg0, %min, %max : ui32
   return
 }
 
 // -----
 
 func.func @uclamp(%arg0 : vector<4xi32>, %min : vector<4xi32>, %max : vector<4xi32>) -> () {
-  // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32>
-  %2 = spv.GLSL.UClamp %arg0, %min, %max : vector<4xi32>
+  // CHECK: spv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xi32>
+  %2 = spv.GL.UClamp %arg0, %min, %max : vector<4xi32>
   return
 }
 
 // -----
 
 func.func @uclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
-  // CHECK: spv.GLSL.UClamp
-  %2 = spv.GLSL.UClamp %arg0, %min, %max : si32
+  // CHECK: spv.GL.UClamp
+  %2 = spv.GL.UClamp %arg0, %min, %max : si32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.SClamp
+// spv.GL.SClamp
 //===----------------------------------------------------------------------===//
 
 func.func @sclamp(%arg0 : si32, %min : si32, %max : si32) -> () {
-  // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
-  %2 = spv.GLSL.SClamp %arg0, %min, %max : si32
+  // CHECK: spv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
+  %2 = spv.GL.SClamp %arg0, %min, %max : si32
   return
 }
 
 // -----
 
 func.func @sclamp(%arg0 : vector<4xsi32>, %min : vector<4xsi32>, %max : vector<4xsi32>) -> () {
-  // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32>
-  %2 = spv.GLSL.SClamp %arg0, %min, %max : vector<4xsi32>
+  // CHECK: spv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<4xsi32>
+  %2 = spv.GL.SClamp %arg0, %min, %max : vector<4xsi32>
   return
 }
 
 // -----
 
 func.func @sclamp(%arg0 : i32, %min : i32, %max : i32) -> () {
-  // CHECK: spv.GLSL.SClamp
-  %2 = spv.GLSL.SClamp %arg0, %min, %max : i32
+  // CHECK: spv.GL.SClamp
+  %2 = spv.GL.SClamp %arg0, %min, %max : i32
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Fma
+// spv.GL.Fma
 //===----------------------------------------------------------------------===//
 
 func.func @fma(%a : f32, %b : f32, %c : f32) -> () {
-  // CHECK: spv.GLSL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-  %2 = spv.GLSL.Fma %a, %b, %c : f32
+  // CHECK: spv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+  %2 = spv.GL.Fma %a, %b, %c : f32
   return
 }
 
 // -----
 
 func.func @fma(%a : vector<3xf32>, %b : vector<3xf32>, %c : vector<3xf32>) -> () {
-  // CHECK: spv.GLSL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
-  %2 = spv.GLSL.Fma %a, %b, %c : vector<3xf32>
+  // CHECK: spv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : vector<3xf32>
+  %2 = spv.GL.Fma %a, %b, %c : vector<3xf32>
   return
 }
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FrexpStruct
+// spv.GL.FrexpStruct
 //===----------------------------------------------------------------------===//
 
 func.func @frexp_struct(%arg0 : f32) -> () {
-  // CHECK: spv.GLSL.FrexpStruct {{%.*}} : f32 -> !spv.struct<(f32, i32)>
-  %2 = spv.GLSL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i32)>
+  // CHECK: spv.GL.FrexpStruct {{%.*}} : f32 -> !spv.struct<(f32, i32)>
+  %2 = spv.GL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i32)>
   return
 }
 
 func.func @frexp_struct_64(%arg0 : f64) -> () {
-  // CHECK: spv.GLSL.FrexpStruct {{%.*}} : f64 -> !spv.struct<(f64, i32)>
-  %2 = spv.GLSL.FrexpStruct %arg0 : f64 -> !spv.struct<(f64, i32)>
+  // CHECK: spv.GL.FrexpStruct {{%.*}} : f64 -> !spv.struct<(f64, i32)>
+  %2 = spv.GL.FrexpStruct %arg0 : f64 -> !spv.struct<(f64, i32)>
   return
 }
 
 func.func @frexp_struct_vec(%arg0 : vector<3xf32>) -> () {
-  // CHECK: spv.GLSL.FrexpStruct {{%.*}} : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<3xi32>)>
-  %2 = spv.GLSL.FrexpStruct %arg0 : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<3xi32>)>
+  // CHECK: spv.GL.FrexpStruct {{%.*}} : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<3xi32>)>
+  %2 = spv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<3xi32>)>
   return
 }
 
 // -----
 
 func.func @frexp_struct_mismatch_type(%arg0 : f32) -> () {
   // expected-error @+1 {{member zero of the resulting struct type must be the same type as the operand}}
-  %2 = spv.GLSL.FrexpStruct %arg0 : f32 -> !spv.struct<(vector<3xf32>, i32)>
+  %2 = spv.GL.FrexpStruct %arg0 : f32 -> !spv.struct<(vector<3xf32>, i32)>
   return
 }
 
 // -----
 
 func.func @frexp_struct_wrong_type(%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.GLSL.FrexpStruct %arg0 : i32 -> !spv.struct<(i32, i32)>
+  %2 = spv.GL.FrexpStruct %arg0 : i32 -> !spv.struct<(i32, i32)>
   return
 }
 
 // -----
 
 func.func @frexp_struct_mismatch_num_components(%arg0 : vector<3xf32>) -> () {
   // expected-error @+1 {{member one of the resulting struct type must have the same number of components as the operand type}}
-  %2 = spv.GLSL.FrexpStruct %arg0 : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<2xi32>)>
+  %2 = spv.GL.FrexpStruct %arg0 : vector<3xf32> -> !spv.struct<(vector<3xf32>, vector<2xi32>)>
   return
 }
 
 // -----
 
 func.func @frexp_struct_not_i32(%arg0 : f32) -> () {
   // expected-error @+1 {{member one of the resulting struct type must be a scalar or vector of 32 bit integer type}}
-  %2 = spv.GLSL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i64)>
+  %2 = spv.GL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i64)>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Ldexp
+// spv.GL.Ldexp
 //===----------------------------------------------------------------------===//
 
 func.func @ldexp(%arg0 : f32, %arg1 : i32) -> () {
-  // CHECK: {{%.*}} = spv.GLSL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32
-  %0 = spv.GLSL.Ldexp %arg0 : f32, %arg1 : i32 -> f32
+  // CHECK: {{%.*}} = spv.GL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32
+  %0 = spv.GL.Ldexp %arg0 : f32, %arg1 : i32 -> f32
   return
 }
 
 // -----
 func.func @ldexp_vec(%arg0 : vector<3xf32>, %arg1 : vector<3xi32>) -> () {
-  // CHECK: {{%.*}} = spv.GLSL.Ldexp {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xi32> -> vector<3xf32>
-  %0 = spv.GLSL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<3xi32> -> vector<3xf32>
+  // CHECK: {{%.*}} = spv.GL.Ldexp {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xi32> -> vector<3xf32>
+  %0 = spv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<3xi32> -> vector<3xf32>
   return
 }
 
 // -----
 
 func.func @ldexp_wrong_type_scalar(%arg0 : f32, %arg1 : vector<2xi32>) -> () {
   // expected-error @+1 {{operands must both be scalars or vectors}}
-  %0 = spv.GLSL.Ldexp %arg0 : f32, %arg1 : vector<2xi32> -> f32
+  %0 = spv.GL.Ldexp %arg0 : f32, %arg1 : vector<2xi32> -> f32
   return
 }
 
 // -----
 
 func.func @ldexp_wrong_type_vec_1(%arg0 : vector<3xf32>, %arg1 : i32) -> () {
   // expected-error @+1 {{operands must both be scalars or vectors}}
-  %0 = spv.GLSL.Ldexp %arg0 : vector<3xf32>, %arg1 : i32 -> vector<3xf32>
+  %0 = spv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : i32 -> vector<3xf32>
   return
 }
 
 // -----
 
 func.func @ldexp_wrong_type_vec_2(%arg0 : vector<3xf32>, %arg1 : vector<2xi32>) -> () {
   // expected-error @+1 {{operands must have the same number of elements}}
-  %0 = spv.GLSL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<2xi32> -> vector<3xf32>
+  %0 = spv.GL.Ldexp %arg0 : vector<3xf32>, %arg1 : vector<2xi32> -> vector<3xf32>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.FMix
+// spv.GL.FMix
 //===----------------------------------------------------------------------===//
 
 func.func @fmix(%arg0 : f32, %arg1 : f32, %arg2 : f32) -> () {
-  // CHECK: {{%.*}} = spv.GLSL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32
-  %0 = spv.GLSL.FMix %arg0 : f32, %arg1 : f32, %arg2 : f32 -> f32
+  // CHECK: {{%.*}} = spv.GL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32
+  %0 = spv.GL.FMix %arg0 : f32, %arg1 : f32, %arg2 : f32 -> f32
   return
 }
 
 func.func @fmix_vector(%arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32>) -> () {
-  // CHECK: {{%.*}} = spv.GLSL.FMix {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32> -> vector<3xf32>
-  %0 = spv.GLSL.FMix %arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32> -> vector<3xf32>
+  // CHECK: {{%.*}} = spv.GL.FMix {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32>, {{%.*}} : vector<3xf32> -> vector<3xf32>
+  %0 = spv.GL.FMix %arg0 : vector<3xf32>, %arg1 : vector<3xf32>, %arg2 : vector<3xf32> -> vector<3xf32>
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.GLSL.Exp
+// spv.GL.Exp
 //===----------------------------------------------------------------------===//
 
 func.func @findumsb(%arg0 : i32) -> () {
-  // CHECK: spv.GLSL.FindUMsb {{%.*}} : i32
-  %2 = spv.GLSL.FindUMsb %arg0 : i32
+  // CHECK: spv.GL.FindUMsb {{%.*}} : i32
+  %2 = spv.GL.FindUMsb %arg0 : i32
   return
 }
 
 func.func @findumsb_vector(%arg0 : vector<3xi32>) -> () {
-  // CHECK: spv.GLSL.FindUMsb {{%.*}} : vector<3xi32>
-  %2 = spv.GLSL.FindUMsb %arg0 : vector<3xi32>
+  // CHECK: spv.GL.FindUMsb {{%.*}} : vector<3xi32>
+  %2 = spv.GL.FindUMsb %arg0 : vector<3xi32>
   return
 }
 
 // -----
 
 func.func @findumsb(%arg0 : i64) -> () {
   // expected-error @+1 {{operand #0 must be Int32 or vector of Int32}}
-  %2 = spv.GLSL.FindUMsb %arg0 : i64
+  %2 = spv.GL.FindUMsb %arg0 : i64
   return
 }

mlir/test/Dialect/SPIRV/Transforms/gl-canonicalize.mlir

-// RUN: mlir-opt -split-input-file -spirv-canonicalize-glsl %s | FileCheck %s
+// RUN: mlir-opt -split-input-file -spirv-canonicalize-gl %s | FileCheck %s
 
 // CHECK-LABEL: func @clamp_fordlessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
 func.func @clamp_fordlessthan(%input: f32, %min: f32, %max: f32) -> f32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.FOrdLessThan %min, %input : f32
   %mid = spv.Select %0, %input, %min : i1, f32
   %1 = spv.FOrdLessThan %mid, %max : f32
   %2 = spv.Select %1, %mid, %max : i1, f32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_fordlessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
 func.func @clamp_fordlessthan(%input: f32, %min: f32, %max: f32) -> f32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.FOrdLessThan %input, %min : f32
   %mid = spv.Select %0, %min, %input : i1, f32
   %1 = spv.FOrdLessThan %max, %input : f32
   %2 = spv.Select %1, %max, %mid : i1, f32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_fordlessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
 func.func @clamp_fordlessthanequal(%input: f32, %min: f32, %max: f32) -> f32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.FOrdLessThanEqual %min, %input : f32
   %mid = spv.Select %0, %input, %min : i1, f32
   %1 = spv.FOrdLessThanEqual %mid, %max : f32
   %2 = spv.Select %1, %mid, %max : i1, f32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_fordlessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: f32, %[[MIN:.*]]: f32, %[[MAX:.*]]: f32)
 func.func @clamp_fordlessthanequal(%input: f32, %min: f32, %max: f32) -> f32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.FClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.FOrdLessThanEqual %input, %min : f32
   %mid = spv.Select %0, %min, %input : i1, f32
   %1 = spv.FOrdLessThanEqual %max, %input : f32
   %2 = spv.Select %1, %max, %mid : i1, f32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : f32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_slessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
 func.func @clamp_slessthan(%input: si32, %min: si32, %max: si32) -> si32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.SLessThan %min, %input : si32
   %mid = spv.Select %0, %input, %min : i1, si32
   %1 = spv.SLessThan %mid, %max : si32
   %2 = spv.Select %1, %mid, %max : i1, si32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : si32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_slessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
 func.func @clamp_slessthan(%input: si32, %min: si32, %max: si32) -> si32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.SLessThan %input, %min : si32
   %mid = spv.Select %0, %min, %input : i1, si32
   %1 = spv.SLessThan %max, %input : si32
   %2 = spv.Select %1, %max, %mid : i1, si32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : si32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_slessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
 func.func @clamp_slessthanequal(%input: si32, %min: si32, %max: si32) -> si32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.SLessThanEqual %min, %input : si32
   %mid = spv.Select %0, %input, %min : i1, si32
   %1 = spv.SLessThanEqual %mid, %max : si32
   %2 = spv.Select %1, %mid, %max : i1, si32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : si32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_slessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: si32, %[[MIN:.*]]: si32, %[[MAX:.*]]: si32)
 func.func @clamp_slessthanequal(%input: si32, %min: si32, %max: si32) -> si32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.SClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.SLessThanEqual %input, %min : si32
   %mid = spv.Select %0, %min, %input : i1, si32
   %1 = spv.SLessThanEqual %max, %input : si32
   %2 = spv.Select %1, %max, %mid : i1, si32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : si32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_ulessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
 func.func @clamp_ulessthan(%input: i32, %min: i32, %max: i32) -> i32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.ULessThan %min, %input : i32
   %mid = spv.Select %0, %input, %min : i1, i32
   %1 = spv.ULessThan %mid, %max : i32
   %2 = spv.Select %1, %mid, %max : i1, i32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : i32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_ulessthan
 //  CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
 func.func @clamp_ulessthan(%input: i32, %min: i32, %max: i32) -> i32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.ULessThan %input, %min : i32
   %mid = spv.Select %0, %min, %input : i1, i32
   %1 = spv.ULessThan %max, %input : i32
   %2 = spv.Select %1, %max, %mid : i1, i32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : i32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_ulessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
 func.func @clamp_ulessthanequal(%input: i32, %min: i32, %max: i32) -> i32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.ULessThanEqual %min, %input : i32
   %mid = spv.Select %0, %input, %min : i1, i32
   %1 = spv.ULessThanEqual %mid, %max : i32
   %2 = spv.Select %1, %mid, %max : i1, i32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : i32
 }
 
 // -----
 
 // CHECK-LABEL: func @clamp_ulessthanequal
 //  CHECK-SAME: (%[[INPUT:.*]]: i32, %[[MIN:.*]]: i32, %[[MAX:.*]]: i32)
 func.func @clamp_ulessthanequal(%input: i32, %min: i32, %max: i32) -> i32 {
-  // CHECK: [[RES:%.*]] = spv.GLSL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
+  // CHECK: [[RES:%.*]] = spv.GL.UClamp %[[INPUT]], %[[MIN]], %[[MAX]]
   %0 = spv.ULessThanEqual %input, %min : i32
   %mid = spv.Select %0, %min, %input : i1, i32
   %1 = spv.ULessThanEqual %max, %input : i32
   %2 = spv.Select %1, %max, %mid : i1, i32
 
   // CHECK-NEXT: spv.ReturnValue [[RES]]
   spv.ReturnValue %2 : i32
 }

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

+// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
+
+spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
+  spv.func @math(%arg0 : f32, %arg1 : f32, %arg2 : i32) "None" {
+    // CHECK: {{%.*}} = spv.GL.Exp {{%.*}} : f32
+    %0 = spv.GL.Exp %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Sqrt {{%.*}} : f32
+    %2 = spv.GL.Sqrt %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Cos {{%.*}} : f32
+    %3 = spv.GL.Cos %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Sin {{%.*}} : f32
+    %4 = spv.GL.Sin %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Tan {{%.*}} : f32
+    %5 = spv.GL.Tan %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Acos {{%.*}} : f32
+    %6 = spv.GL.Acos %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Asin {{%.*}} : f32
+    %7 = spv.GL.Asin %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Atan {{%.*}} : f32
+    %8 = spv.GL.Atan %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Sinh {{%.*}} : f32
+    %9 = spv.GL.Sinh %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Cosh {{%.*}} : f32
+    %10 = spv.GL.Cosh %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.Pow {{%.*}} : f32
+    %11 = spv.GL.Pow %arg0, %arg1 : f32
+    // CHECK: {{%.*}} = spv.GL.Round {{%.*}} : f32
+    %12 = spv.GL.Round %arg0 : f32
+    // CHECK: {{%.*}} = spv.GL.FrexpStruct {{%.*}} : f32 -> !spv.struct<(f32, i32)>
+    %13 = spv.GL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i32)>
+    // CHECK: {{%.*}} = spv.GL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32
+    %14 = spv.GL.Ldexp %arg0 : f32, %arg2 : i32 -> f32
+    // CHECK: {{%.*}} = spv.GL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32
+    %15 = spv.GL.FMix %arg0 : f32, %arg1 : f32, %arg0 : f32 -> f32
+    spv.Return
+  }
+
+  spv.func @maxmin(%arg0 : f32, %arg1 : f32, %arg2 : i32, %arg3 : i32) "None" {
+    // CHECK: {{%.*}} = spv.GL.FMax {{%.*}}, {{%.*}} : f32
+    %1 = spv.GL.FMax %arg0, %arg1 : f32
+    // CHECK: {{%.*}} = spv.GL.SMax {{%.*}}, {{%.*}} : i32
+    %2 = spv.GL.SMax %arg2, %arg3 : i32
+    // CHECK: {{%.*}} = spv.GL.UMax {{%.*}}, {{%.*}} : i32
+    %3 = spv.GL.UMax %arg2, %arg3 : i32
+
+    // CHECK: {{%.*}} = spv.GL.FMin {{%.*}}, {{%.*}} : f32
+    %4 = spv.GL.FMin %arg0, %arg1 : f32
+    // CHECK: {{%.*}} = spv.GL.SMin {{%.*}}, {{%.*}} : i32
+    %5 = spv.GL.SMin %arg2, %arg3 : i32
+    // CHECK: {{%.*}} = spv.GL.UMin {{%.*}}, {{%.*}} : i32
+    %6 = spv.GL.UMin %arg2, %arg3 : i32
+    spv.Return
+  }
+
+  spv.func @fclamp(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
+    // CHECK: spv.GL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+    %13 = spv.GL.FClamp %arg0, %arg1, %arg2 : f32
+    spv.Return
+  }
+
+  spv.func @uclamp(%arg0 : ui32, %arg1 : ui32, %arg2 : ui32) "None" {
+    // CHECK: spv.GL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : i32
+    %13 = spv.GL.UClamp %arg0, %arg1, %arg2 : ui32
+    spv.Return
+  }
+
+  spv.func @sclamp(%arg0 : si32, %arg1 : si32, %arg2 : si32) "None" {
+    // CHECK: spv.GL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
+    %13 = spv.GL.SClamp %arg0, %arg1, %arg2 : si32
+    spv.Return
+  }
+
+  spv.func @fma(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
+    // CHECK: spv.GL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
+    %13 = spv.GL.Fma %arg0, %arg1, %arg2 : f32
+    spv.Return
+  }
+
+  spv.func @findumsb(%arg0 : i32) "None" {
+    // CHECK: spv.GL.FindUMsb {{%.*}} : i32
+    %2 = spv.GL.FindUMsb %arg0 : i32
+    spv.Return
+  }
+}

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

-// RUN: mlir-translate -test-spirv-roundtrip %s | FileCheck %s
-
-spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
-  spv.func @math(%arg0 : f32, %arg1 : f32, %arg2 : i32) "None" {
-    // CHECK: {{%.*}} = spv.GLSL.Exp {{%.*}} : f32
-    %0 = spv.GLSL.Exp %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Sqrt {{%.*}} : f32
-    %2 = spv.GLSL.Sqrt %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Cos {{%.*}} : f32
-    %3 = spv.GLSL.Cos %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Sin {{%.*}} : f32
-    %4 = spv.GLSL.Sin %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Tan {{%.*}} : f32
-    %5 = spv.GLSL.Tan %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Acos {{%.*}} : f32
-    %6 = spv.GLSL.Acos %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Asin {{%.*}} : f32
-    %7 = spv.GLSL.Asin %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Atan {{%.*}} : f32
-    %8 = spv.GLSL.Atan %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Sinh {{%.*}} : f32
-    %9 = spv.GLSL.Sinh %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Cosh {{%.*}} : f32
-    %10 = spv.GLSL.Cosh %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Pow {{%.*}} : f32
-    %11 = spv.GLSL.Pow %arg0, %arg1 : f32
-    // CHECK: {{%.*}} = spv.GLSL.Round {{%.*}} : f32
-    %12 = spv.GLSL.Round %arg0 : f32
-    // CHECK: {{%.*}} = spv.GLSL.FrexpStruct {{%.*}} : f32 -> !spv.struct<(f32, i32)>
-    %13 = spv.GLSL.FrexpStruct %arg0 : f32 -> !spv.struct<(f32, i32)>
-    // CHECK: {{%.*}} = spv.GLSL.Ldexp {{%.*}} : f32, {{%.*}} : i32 -> f32
-    %14 = spv.GLSL.Ldexp %arg0 : f32, %arg2 : i32 -> f32
-    // CHECK: {{%.*}} = spv.GLSL.FMix {{%.*}} : f32, {{%.*}} : f32, {{%.*}} : f32 -> f32
-    %15 = spv.GLSL.FMix %arg0 : f32, %arg1 : f32, %arg0 : f32 -> f32
-    spv.Return
-  }
-
-  spv.func @maxmin(%arg0 : f32, %arg1 : f32, %arg2 : i32, %arg3 : i32) "None" {
-    // CHECK: {{%.*}} = spv.GLSL.FMax {{%.*}}, {{%.*}} : f32
-    %1 = spv.GLSL.FMax %arg0, %arg1 : f32
-    // CHECK: {{%.*}} = spv.GLSL.SMax {{%.*}}, {{%.*}} : i32
-    %2 = spv.GLSL.SMax %arg2, %arg3 : i32
-    // CHECK: {{%.*}} = spv.GLSL.UMax {{%.*}}, {{%.*}} : i32
-    %3 = spv.GLSL.UMax %arg2, %arg3 : i32
-
-    // CHECK: {{%.*}} = spv.GLSL.FMin {{%.*}}, {{%.*}} : f32
-    %4 = spv.GLSL.FMin %arg0, %arg1 : f32
-    // CHECK: {{%.*}} = spv.GLSL.SMin {{%.*}}, {{%.*}} : i32
-    %5 = spv.GLSL.SMin %arg2, %arg3 : i32
-    // CHECK: {{%.*}} = spv.GLSL.UMin {{%.*}}, {{%.*}} : i32
-    %6 = spv.GLSL.UMin %arg2, %arg3 : i32
-    spv.Return
-  }
-
-  spv.func @fclamp(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
-    // CHECK: spv.GLSL.FClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-    %13 = spv.GLSL.FClamp %arg0, %arg1, %arg2 : f32
-    spv.Return
-  }
-
-  spv.func @uclamp(%arg0 : ui32, %arg1 : ui32, %arg2 : ui32) "None" {
-    // CHECK: spv.GLSL.UClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : i32
-    %13 = spv.GLSL.UClamp %arg0, %arg1, %arg2 : ui32
-    spv.Return
-  }
-
-  spv.func @sclamp(%arg0 : si32, %arg1 : si32, %arg2 : si32) "None" {
-    // CHECK: spv.GLSL.SClamp {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : si32
-    %13 = spv.GLSL.SClamp %arg0, %arg1, %arg2 : si32
-    spv.Return
-  }
-
-  spv.func @fma(%arg0 : f32, %arg1 : f32, %arg2 : f32) "None" {
-    // CHECK: spv.GLSL.Fma {{%[^,]*}}, {{%[^,]*}}, {{%[^,]*}} : f32
-    %13 = spv.GLSL.Fma %arg0, %arg1, %arg2 : f32
-    spv.Return
-  }
-
-  spv.func @findumsb(%arg0 : i32) "None" {
-    // CHECK: spv.GLSL.FindUMsb {{%.*}} : i32
-    %2 = spv.GLSL.FindUMsb %arg0 : i32
-    spv.Return
-  }
-}