[MLIR][SPIRV] Rename `spv.spcConstant...` to `spv.SpcConstant...`.

[ergawy]

Summary

To unify the naming scheme across all ops in the SPIR-V dialect, we are
moving from spv.camelCase to spv.CamelCase everywhere.

[antiagainst]

LGTM. But forgot to mark it as accepted before landing. :)

mlir/docs/Dialects/SPIR-V.md

*   Normal constants are not placed in `spv.module`'s region; they are localized
     attributes are made unique in `MLIRContext`.
 
 #### Adopt symbol-based global variables and specialization constant
 
 *   Global variables are defined with the `spv.globalVariable` op. They do not
     generate SSA values. Instead they have symbols and should be referenced via
     symbols. To use global variables in a function block, `spv.mlir.addressof` is
     needed to turn the symbol into an SSA value.
-*   Specialization constants are defined with the `spv.specConstant` op. Similar
+*   Specialization constants are defined with the `spv.SpecConstant` op. Similar
     to global variables, they do not generate SSA values and have symbols for
     reference, too. `spv.mlir.referenceof` is needed to turn the symbol into an SSA
     value for use in a function block.
 
 The above choices enables functions in the SPIR-V dialect to be isolated and
 explicit capturing.
 
 #### Disallow implicit capturing in functions
*   `OpConstant*` instructions are materialized as `spv.constant` at each use
     site.
 *   `OpVariable` instructions will be converted to `spv.globalVariable` ops if
     in module-level; otherwise they will be converted into `spv.Variable` ops.
 *   Every use of a module-level `OpVariable` instruction will materialize a
     `spv.mlir.addressof` op to turn the symbol of the corresponding
     `spv.globalVariable` into an SSA value.
 *   Every use of a `OpSpecConstant` instruction will materialize a
     `spv.mlir.referenceof` op to turn the symbol of the corresponding
-    `spv.specConstant` into an SSA value.
+    `spv.SpecConstant` into an SSA value.
 *   `OpPhi` instructions are converted to block arguments.
 *   Structured control flow are placed inside `spv.selection` and `spv.loop`.
 
 ## Conversions
 
 One of the main features of MLIR is the ability to progressively lower from
 dialects that capture programmer abstraction into dialects that are closer to a
 machine representation, like SPIR-V dialect. This progressive lowering through

mlir/docs/SPIRVToLLVMDialectConversion.md

 *   spv.GLSL.Cosh
 *   spv.GLSL.FSign
 *   spv.GLSL.SAbs
 *   spv.GLSL.Sinh
 *   spv.GLSL.SSign
 *   spv.MemoryBarrier
 *   spv.mlir.referenceof
 *   spv.SMod
-*   spv.specConstant
+*   spv.SpecConstant
 *   spv.Unreachable
 *   spv.VectorExtractDynamic
 
 ## Control flow conversion
 
 ### Branch ops
 
 `spv.Branch` and `spv.BranchConditional` are mapped to `llvm.br` and

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

def SPV_ReferenceOfOp : SPV_Op<"mlir.referenceof", [NoSideEffect]> {
 
   let autogenSerialization = 0;
 
   let assemblyFormat = "$spec_const attr-dict `:` type($reference)";
 }
 
 // -----
 
-def SPV_SpecConstantOp : SPV_Op<"specConstant", [InModuleScope, Symbol]> {
+def SPV_SpecConstantOp : SPV_Op<"SpecConstant", [InModuleScope, Symbol]> {
   let summary = "The op that declares a SPIR-V specialization constant";
 
   let description = [{
     This op declares a SPIR-V scalar specialization constant. SPIR-V has
     multiple constant instructions covering different scalar types:
 
     * `OpSpecConstantTrue` and `OpSpecConstantFalse` for boolean constants
     * `OpSpecConstant` for scalar constants
 
     Similar as `spv.constant`, this op represents all of the above cases.
     `OpSpecConstantComposite` and `OpSpecConstantOp` are modelled with
     separate ops.
 
     <!-- End of AutoGen section -->
 
     ```
-    spv-spec-constant-op ::= `spv.specConstant` symbol-ref-id
+    spv-spec-constant-op ::= `spv.SpecConstant` symbol-ref-id
                              `spec_id(` integer `)`
                              `=` attribute-value (`:` spirv-type)?
     ```
 
     where `spec_id` specifies the SPIR-V SpecId decoration associated with
     the op.
 
     #### Example:
 
     ```mlir
-    spv.specConstant @spec_const1 = true
-    spv.specConstant @spec_const2 spec_id(5) = 42 : i32
+    spv.SpecConstant @spec_const1 = true
+    spv.SpecConstant @spec_const2 spec_id(5) = 42 : i32
     ```
   }];
 
   let arguments = (ins
     StrAttr:$sym_name,
     AnyAttr:$default_value
   );
 
   let results = (outs);
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 }
 
 // -----
 
-def SPV_SpecConstantCompositeOp : SPV_Op<"specConstantComposite", [
+def SPV_SpecConstantCompositeOp : SPV_Op<"SpecConstantComposite", [
     InModuleScope, Symbol]> {
   let summary = "Declare a new composite specialization constant.";
 
   let description = [{
     This op declares a SPIR-V composite specialization constant. This covers
     the `OpSpecConstantComposite` SPIR-V instruction. Scalar constants are
-    covered by `spv.specConstant`.
+    covered by `spv.SpecConstant`.
 
     A constituent of a spec constant composite can be:
     - A symbol referring of another spec constant.
     - The SSA ID of a non-specialization constant (i.e. defined through
-      `spv.specConstant`).
+      `spv.SpecConstant`).
     - The SSA ID of a `spv.undef`.
 
     ```
-    spv-spec-constant-composite-op ::= `spv.specConstantComposite` symbol-ref-id ` (`
+    spv-spec-constant-composite-op ::= `spv.SpecConstantComposite` symbol-ref-id ` (`
                                        symbol-ref-id (`, ` symbol-ref-id)*
                                        `) :` composite-type
     ```
 
      where `composite-type` is some non-scalar type that can be represented in the `spv`
      dialect: `spv.struct`, `spv.array`, or `vector`.
 
      #### Example:
 
      ```mlir
-     spv.specConstant @sc1 = 1   : i32
-     spv.specConstant @sc2 = 2.5 : f32
-     spv.specConstant @sc3 = 3.5 : f32
-     spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<i32, f32, f32>
+     spv.SpecConstant @sc1 = 1   : i32
+     spv.SpecConstant @sc2 = 2.5 : f32
+     spv.SpecConstant @sc3 = 3.5 : f32
+     spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<i32, f32, f32>
      ```
 
     TODO Add support for constituents that are:
     - regular constants.
     - undef.
     - spec constant composite.
   }];
 

mlir/include/mlir/Dialect/SPIRV/Linking/ModuleCombiner.h

 ///   other symbol.
 ///   - If none of the 2 conflicting ops are spv.func, then rename either.
 ///
 /// For deduplication, the following 3 cases are taken into consideration:
 ///
 ///   - If 2 spv.globalVariable's have either the same descriptor set + binding
 ///   or the same build_in attribute value, then replace one of them using the
 ///   other.
-///   - If 2 spv.specConstant's have the same spec_id attribute value, then
+///   - If 2 spv.SpecConstant's have the same spec_id attribute value, then
 ///   replace one of them using the other.
 ///   - If 2 spv.func's are identical replace one of them using the other.
 ///
 /// In all cases, the references to the updated symbol (whether renamed or
 /// deduplicated) are also updated to reflect the change.
 ///
 /// \param modules the list of modules to combine. Input modules are not
 /// modified.

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

if (auto init =
     Operation *initOp = SymbolTable::lookupNearestSymbolFrom(
         varOp->getParentOp(), init.getValue());
     // TODO: Currently only variable initialization with specialization
     // constants and other variables is supported. They could be normal
     // constants in the module scope as well.
     if (!initOp ||
         !isa<spirv::GlobalVariableOp, spirv::SpecConstantOp>(initOp)) {
       return varOp.emitOpError("initializer must be result of a "
-                               "spv.specConstant or spv.globalVariable op");
+                               "spv.SpecConstant or spv.globalVariable op");
     }
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.GroupBroadcast
static LogicalResult verify(spirv::ReferenceOfOp referenceOfOp) {
 
   auto specConstCompositeOp =
       dyn_cast_or_null<spirv::SpecConstantCompositeOp>(specConstSym);
   if (specConstCompositeOp)
     constType = specConstCompositeOp.type();
 
   if (!specConstOp && !specConstCompositeOp)
     return referenceOfOp.emitOpError(
-        "expected spv.specConstant or spv.SpecConstantComposite symbol");
+        "expected spv.SpecConstant or spv.SpecConstantComposite symbol");
 
   if (referenceOfOp.reference().getType() != constType)
     return referenceOfOp.emitOpError("result type mismatch with the referenced "
                                      "specialization constant's type");
 
   return success();
 }
 
builder.create<spirv::BranchConditionalOp>(
         /*trueArguments=*/ArrayRef<Value>(), mergeBlock,
         /*falseArguments=*/ArrayRef<Value>());
   }
 
   return selectionOp;
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstant
+// spv.SpecConstant
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseSpecConstantOp(OpAsmParser &parser,
                                        OperationState &state) {
   StringAttr nameAttr;
   Attribute valueAttr;
 
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
static LogicalResult verifyMatrixTimesMatrix(spirv::MatrixTimesMatrixOp op) {
   if (leftMatrix.getNumRows() != resultMatrix.getNumRows())
     return op.emitError("left and result matrices must have equal rows'"
                         " count");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite
+// spv.SpecConstantComposite
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseSpecConstantCompositeOp(OpAsmParser &parser,
                                                 OperationState &state) {
 
   StringAttr compositeName;
   if (parser.parseSymbolName(compositeName, SymbolTable::getSymbolAttrName(),
                              state.attributes))

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

spv.func @variable_init_global_variable() -> () "None" {
     %1 = spv.Variable init(%0) : !spv.ptr<!spv.ptr<f32, Workgroup>, Function>
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc = 42 : i32
+  spv.SpecConstant @sc = 42 : i32
   // CHECK-LABEL: @variable_init_spec_constant
   spv.func @variable_init_spec_constant() -> () "None" {
     %0 = spv.mlir.referenceof @sc : i32
     // CHECK: spv.Variable init(%0) : !spv.ptr<i32, Function>
     %1 = spv.Variable init(%0) : !spv.ptr<i32, Function>
     spv.Return
   }
 }

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

 //   %0 = spv.constant 4.0 : f32
 //   // CHECK1: spv.Variable init(%0) : !spv.ptr<f32, Private>
 //   spv.globalVariable @var1 init(%0) : !spv.ptr<f32, Private>
 // }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc = 4.0 : f32
+  spv.SpecConstant @sc = 4.0 : f32
   // CHECK: spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
   spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
 }
 
 // -----
 
 // Allow initializers coming from other module-like ops
-spv.specConstant @sc = 4.0 : f32
+spv.SpecConstant @sc = 4.0 : f32
 // CHECK: spv.globalVariable @var initializer(@sc)
 spv.globalVariable @var initializer(@sc) : !spv.ptr<f32, Private>
 
 // -----
 
 spv.module Logical GLSL450 {
   // CHECK: spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform>
   spv.globalVariable @var0 bind(1, 2) : !spv.ptr<f32, Uniform>

 spv.module Logical GLSL450 {
   // expected-error @+1 {{expected spv.ptr type}}
   spv.globalVariable @var0 : f32
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  // expected-error @+1 {{op initializer must be result of a spv.specConstant or spv.globalVariable op}}
+  // expected-error @+1 {{op initializer must be result of a spv.SpecConstant or spv.globalVariable op}}
   spv.globalVariable @var0 initializer(@var1) : !spv.ptr<f32, Private>
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   // expected-error @+1 {{storage class cannot be 'Generic'}}
   spv.globalVariable @var0 : !spv.ptr<f32, Generic>

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // spv.mlir.referenceof
 //===----------------------------------------------------------------------===//
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = false
-  spv.specConstant @sc2 = 42 : i64
-  spv.specConstant @sc3 = 1.5 : f32
+  spv.SpecConstant @sc1 = false
+  spv.SpecConstant @sc2 = 42 : i64
+  spv.SpecConstant @sc3 = 1.5 : f32
 
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i1, i64, f32)>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i1, i64, f32)>
 
   // CHECK-LABEL: @reference
   spv.func @reference() -> i1 "None" {
     // CHECK: spv.mlir.referenceof @sc1 : i1
     %0 = spv.mlir.referenceof @sc1 : i1
     spv.ReturnValue %0 : i1
   }
 
spv.func @compute() -> f32 "None" {
     %2 = spv.FAdd %0, %1 : f32
     spv.ReturnValue %2 : f32
   }
 }
 
 // -----
 
 // Allow taking reference of spec constant in other module-like ops
-spv.specConstant @sc = 5 : i32
+spv.SpecConstant @sc = 5 : i32
 func @reference_of() {
   // CHECK: spv.mlir.referenceof @sc
   %0 = spv.mlir.referenceof @sc : i32
   return
 }
 
 // -----
 
-spv.specConstant @sc = 5 : i32
-spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32>
+spv.SpecConstant @sc = 5 : i32
+spv.SpecConstantComposite @scc (@sc) : !spv.array<1 x i32>
 
 func @reference_of_composite() {
   // CHECK: spv.mlir.referenceof @scc : !spv.array<1 x i32>
   %0 = spv.mlir.referenceof @scc : !spv.array<1 x i32>
   %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<1 x i32>
   return
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   spv.func @foo() -> () "None" {
-    // expected-error @+1 {{expected spv.specConstant or spv.SpecConstantComposite symbol}}
+    // expected-error @+1 {{expected spv.SpecConstant or spv.SpecConstantComposite symbol}}
     %0 = spv.mlir.referenceof @sc : i32
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc = 42 : i32
+  spv.SpecConstant @sc = 42 : i32
   spv.func @foo() -> () "None" {
     // expected-error @+1 {{result type mismatch with the referenced specialization constant's type}}
     %0 = spv.mlir.referenceof @sc : f32
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc = 42 : i32
-  spv.specConstantComposite @scc (@sc) : !spv.array<1 x i32>
+  spv.SpecConstant @sc = 42 : i32
+  spv.SpecConstantComposite @scc (@sc) : !spv.array<1 x i32>
   spv.func @foo() -> () "None" {
     // expected-error @+1 {{result type mismatch with the referenced specialization constant's type}}
     %0 = spv.mlir.referenceof @scc : f32
     spv.Return
   }
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.specConstant
+// spv.SpecConstant
 //===----------------------------------------------------------------------===//
 
 spv.module Logical GLSL450 {
-  // CHECK: spv.specConstant @sc1 = false
-  spv.specConstant @sc1 = false
-  // CHECK: spv.specConstant @sc2 spec_id(5) = 42 : i64
-  spv.specConstant @sc2 spec_id(5) = 42 : i64
-  // CHECK: spv.specConstant @sc3 = 1.500000e+00 : f32
-  spv.specConstant @sc3 = 1.5 : f32
+  // CHECK: spv.SpecConstant @sc1 = false
+  spv.SpecConstant @sc1 = false
+  // CHECK: spv.SpecConstant @sc2 spec_id(5) = 42 : i64
+  spv.SpecConstant @sc2 spec_id(5) = 42 : i64
+  // CHECK: spv.SpecConstant @sc3 = 1.500000e+00 : f32
+  spv.SpecConstant @sc3 = 1.5 : f32
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   // expected-error @+1 {{SpecId cannot be negative}}
-  spv.specConstant @sc2 spec_id(-5) = 42 : i64
+  spv.SpecConstant @sc2 spec_id(-5) = 42 : i64
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   // expected-error @+1 {{default value bitwidth disallowed}}
-  spv.specConstant @sc = 15 : i4
+  spv.SpecConstant @sc = 15 : i4
 }
 
 // -----
 
 spv.module Logical GLSL450 {
   // expected-error @+1 {{default value can only be a bool, integer, or float scalar}}
-  spv.specConstant @sc = dense<[2, 3]> : vector<2xi32>
+  spv.SpecConstant @sc = dense<[2, 3]> : vector<2xi32>
 }
 
 // -----
 
 func @use_in_function() -> () {
   // expected-error @+1 {{op must appear in a module-like op's block}}
-  spv.specConstant @sc = false
+  spv.SpecConstant @sc = false
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite
+// spv.SpecConstantComposite
 //===----------------------------------------------------------------------===//
 
 spv.module Logical GLSL450 {
   // expected-error @+1 {{result type must be a composite type}}
-  spv.specConstantComposite @scc2 (@sc1, @sc2, @sc3) : i32
+  spv.SpecConstantComposite @scc2 (@sc1, @sc2, @sc3) : i32
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite (spv.array)
+// spv.SpecConstantComposite (spv.array)
 //===----------------------------------------------------------------------===//
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1.5 : f32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
-  // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
+  spv.SpecConstant @sc1 = 1.5 : f32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
+  // CHECK: spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = false
-  spv.specConstant @sc2 spec_id(5) = 42 : i64
-  spv.specConstant @sc3 = 1.5 : f32
+  spv.SpecConstant @sc1 = false
+  spv.SpecConstant @sc2 spec_id(5) = 42 : i64
+  spv.SpecConstant @sc3 = 1.5 : f32
   // expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<4 x f32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<4 x f32>
 
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1   : i32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
+  spv.SpecConstant @sc1 = 1   : i32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
   // expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.array<3 x f32>
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite (spv.struct)
+// spv.SpecConstantComposite (spv.struct)
 //===----------------------------------------------------------------------===//
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1   : i32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
-  // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
+  spv.SpecConstant @sc1 = 1   : i32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
+  // CHECK: spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1   : i32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
+  spv.SpecConstant @sc1 = 1   : i32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
   // expected-error @+1 {{has incorrect number of operands: expected 2, but provided 3}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32)>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32)>
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1.5 : f32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
+  spv.SpecConstant @sc1 = 1.5 : f32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
   // expected-error @+1 {{has incorrect types of operands: expected 'i32', but provided 'f32'}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : !spv.struct<(i32, f32, f32)>
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite (vector)
+// spv.SpecConstantComposite (vector)
 //===----------------------------------------------------------------------===//
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1.5 : f32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
-  // CHECK: spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3 x f32>
+  spv.SpecConstant @sc1 = 1.5 : f32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
+  // CHECK: spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3 x f32>
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = false
-  spv.specConstant @sc2 spec_id(5) = 42 : i64
-  spv.specConstant @sc3 = 1.5 : f32
+  spv.SpecConstant @sc1 = false
+  spv.SpecConstant @sc2 spec_id(5) = 42 : i64
+  spv.SpecConstant @sc3 = 1.5 : f32
   // expected-error @+1 {{has incorrect number of operands: expected 4, but provided 3}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<4xf32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : vector<4xf32>
 
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1   : i32
-  spv.specConstant @sc2 = 2.5 : f32
-  spv.specConstant @sc3 = 3.5 : f32
+  spv.SpecConstant @sc1 = 1   : i32
+  spv.SpecConstant @sc2 = 2.5 : f32
+  spv.SpecConstant @sc3 = 3.5 : f32
   // expected-error @+1 {{has incorrect types of operands: expected 'f32', but provided 'i32'}}
-  spv.specConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
+  spv.SpecConstantComposite @scc (@sc1, @sc2, @sc3) : vector<3xf32>
 }
 
 //===----------------------------------------------------------------------===//
-// spv.specConstantComposite (spv.coopmatrix)
+// spv.SpecConstantComposite (spv.coopmatrix)
 //===----------------------------------------------------------------------===//
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc1 = 1.5 : f32
+  spv.SpecConstant @sc1 = 1.5 : f32
   // expected-error @+1 {{unsupported composite type}}
-  spv.specConstantComposite @scc (@sc1) : !spv.coopmatrix<8x16xf32, Device>
+  spv.SpecConstantComposite @scc (@sc1) : !spv.coopmatrix<8x16xf32, Device>
 }
 
 //===----------------------------------------------------------------------===//
 // spv.SpecConstantOperation
 //===----------------------------------------------------------------------===//
 
 // -----
 
spv.func @foo() -> i32 "None" {
 
     spv.ReturnValue %2 : i32
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 {
-  spv.specConstant @sc = 42 : i32
+  spv.SpecConstant @sc = 42 : i32
 
   spv.func @foo() -> i32 "None" {
     // CHECK: [[SC:%.*]] = spv.mlir.referenceof @sc
     %0 = spv.mlir.referenceof @sc : i32
     // CHECK: spv.SpecConstantOperation wraps "spv.ISub"([[SC]], [[SC]]) : (i32, i32) -> i32
     %1 = spv.SpecConstantOperation wraps "spv.ISub"(%0, %0) : (i32, i32) -> i32
     spv.ReturnValue %1 : i32
   }

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/basic.mlir

 // RUN: mlir-opt -test-spirv-module-combiner -split-input-file -verify-diagnostics %s | FileCheck %s
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @m1_sc
-// CHECK-NEXT:     spv.specConstant @m2_sc
+// CHECK-NEXT:     spv.SpecConstant @m1_sc
+// CHECK-NEXT:     spv.SpecConstant @m2_sc
 // CHECK-NEXT:     spv.func @variable_init_spec_constant
 // CHECK-NEXT:       spv.mlir.referenceof @m2_sc
 // CHECK-NEXT:       spv.Variable init
 // CHECK-NEXT:       spv.Return
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @m1_sc = 42.42 : f32
+  spv.SpecConstant @m1_sc = 42.42 : f32
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @m2_sc = 42 : i32
+  spv.SpecConstant @m2_sc = 42 : i32
   spv.func @variable_init_spec_constant() -> () "None" {
     %0 = spv.mlir.referenceof @m2_sc : i32
     %1 = spv.Variable init(%0) : !spv.ptr<i32, Function>
     spv.Return
   }
 }
 }
 

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/conflict-resolution.mlir

 // Resolve conflicting funcOp and specConstantOp.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
-// CHECK-NEXT:     spv.specConstant @foo_1
+// CHECK-NEXT:     spv.SpecConstant @foo_1
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @foo = -5 : i32
+  spv.SpecConstant @foo = -5 : i32
 }
 }
 
 // -----
 
 // Resolve conflicting funcOp and specConstantOp and update the spec constant's
 // references.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
-// CHECK-NEXT:     spv.specConstant @foo_1
+// CHECK-NEXT:     spv.SpecConstant @foo_1
 // CHECK-NEXT:     spv.func @bar
 // CHECK-NEXT:       spv.mlir.referenceof @foo_1
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @foo = -5 : i32
+  spv.SpecConstant @foo = -5 : i32
 
   spv.func @bar() -> i32 "None" {
     %0 = spv.mlir.referenceof @foo : i32 
     spv.ReturnValue %0 : i32
   }
 }
 }
 
 // -----
 
 // Resolve conflicting specConstantOp and funcOp and update the spec constant's
 // references.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @foo_1
+// CHECK-NEXT:     spv.SpecConstant @foo_1
 // CHECK-NEXT:     spv.func @bar
 // CHECK-NEXT:       spv.mlir.referenceof @foo_1
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @foo = -5 : i32
+  spv.SpecConstant @foo = -5 : i32
 
   spv.func @bar() -> i32 "None" {
     %0 = spv.mlir.referenceof @foo : i32
     spv.ReturnValue %0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 }
 
 // -----
 
 // Resolve conflicting funcOp and specConstantCompositeOp.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
-// CHECK-NEXT:     spv.specConstant @bar
-// CHECK-NEXT:     spv.specConstantComposite @foo_1 (@bar, @bar)
+// CHECK-NEXT:     spv.SpecConstant @bar
+// CHECK-NEXT:     spv.SpecConstantComposite @foo_1 (@bar, @bar)
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 }
 }
 
 // -----
 
 // Resolve conflicting funcOp and specConstantCompositeOp and update the spec
 // constant's references.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
-// CHECK-NEXT:     spv.specConstant @bar
-// CHECK-NEXT:     spv.specConstantComposite @foo_1 (@bar, @bar)
+// CHECK-NEXT:     spv.SpecConstant @bar
+// CHECK-NEXT:     spv.SpecConstantComposite @foo_1 (@bar, @bar)
 // CHECK-NEXT:     spv.func @baz
 // CHECK-NEXT:       spv.mlir.referenceof @foo_1
 // CHECK-NEXT:       spv.CompositeExtract
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 
   spv.func @baz() -> i32 "None" {
     %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
     %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
     spv.ReturnValue %1 : i32
   }
 }
 }
 
 // -----
 
 // Resolve conflicting specConstantCompositeOp and funcOp and update the spec
 // constant's references.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @bar
-// CHECK-NEXT:     spv.specConstantComposite @foo_1 (@bar, @bar)
+// CHECK-NEXT:     spv.SpecConstant @bar
+// CHECK-NEXT:     spv.SpecConstantComposite @foo_1 (@bar, @bar)
 // CHECK-NEXT:     spv.func @baz
 // CHECK-NEXT:       spv.mlir.referenceof @foo_1
 // CHECK-NEXT:       spv.CompositeExtract
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 
   spv.func @baz() -> i32 "None" {
     %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
     %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
     spv.ReturnValue %1 : i32
   }
 }
 
 spv.module Logical GLSL450 {
   spv.func @foo(%arg0 : i32) -> i32 "None" {
     spv.ReturnValue %arg0 : i32
   }
 }
 }
 
 // -----
 
 // Resolve conflicting spec constants and funcOps and update the spec constant's
 // references.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @bar_1
-// CHECK-NEXT:     spv.specConstantComposite @foo_2 (@bar_1, @bar_1)
+// CHECK-NEXT:     spv.SpecConstant @bar_1
+// CHECK-NEXT:     spv.SpecConstantComposite @foo_2 (@bar_1, @bar_1)
 // CHECK-NEXT:     spv.func @baz
 // CHECK-NEXT:       spv.mlir.referenceof @foo_2
 // CHECK-NEXT:       spv.CompositeExtract
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @bar
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 
   spv.func @baz() -> i32 "None" {
     %0 = spv.mlir.referenceof @foo : !spv.array<2 x i32>
     %1 = spv.CompositeExtract %0[0 : i32] : !spv.array<2 x i32>
     spv.ReturnValue %1 : i32
   }
 }
 

 // -----
 
 // Resolve conflicting globalVariableOp and specConstantOp.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.globalVariable @foo_1
 
-// CHECK-NEXT:     spv.specConstant @foo
+// CHECK-NEXT:     spv.SpecConstant @foo
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @foo = -5 : i32
+  spv.SpecConstant @foo = -5 : i32
 }
 }
 
 // -----
 
 // Resolve conflicting specConstantOp and globalVariableOp.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @foo_1
+// CHECK-NEXT:     spv.SpecConstant @foo_1
 
 // CHECK-NEXT:     spv.globalVariable @foo
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @foo = -5 : i32
+  spv.SpecConstant @foo = -5 : i32
 }
 
 spv.module Logical GLSL450 {
   spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
 }
 }
 
 // -----
 
 // Resolve conflicting globalVariableOp and specConstantCompositeOp.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
 // CHECK-NEXT:     spv.globalVariable @foo_1
 
-// CHECK-NEXT:     spv.specConstant @bar
-// CHECK-NEXT:     spv.specConstantComposite @foo (@bar, @bar)
+// CHECK-NEXT:     spv.SpecConstant @bar
+// CHECK-NEXT:     spv.SpecConstantComposite @foo (@bar, @bar)
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
   spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 }
 }
 
 // -----
 
 // Resolve conflicting globalVariableOp and specConstantComposite.
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @bar
-// CHECK-NEXT:     spv.specConstantComposite @foo_1 (@bar, @bar)
+// CHECK-NEXT:     spv.SpecConstant @bar
+// CHECK-NEXT:     spv.SpecConstantComposite @foo_1 (@bar, @bar)
 
 // CHECK-NEXT:     spv.globalVariable @foo
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @bar = -5 : i32
-  spv.specConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
+  spv.SpecConstant @bar = -5 : i32
+  spv.SpecConstantComposite @foo (@bar, @bar) : !spv.array<2 x i32>
 }
 
 spv.module Logical GLSL450 {
   spv.globalVariable @foo bind(1, 0) : !spv.ptr<f32, Input>
 }
 }

mlir/test/Dialect/SPIRV/Linking/ModuleCombiner/deduplication.mlir

spv.module Logical GLSL450 {
   }
 }
 }
 
 // -----
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @foo spec_id(5)
+// CHECK-NEXT:     spv.SpecConstant @foo spec_id(5)
 
 // CHECK-NEXT:     spv.func @use_foo()
 // CHECK-NEXT:       %0 = spv.mlir.referenceof @foo
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @use_bar()
 // CHECK-NEXT:       %0 = spv.mlir.referenceof @foo
 // CHECK-NEXT:       spv.FAdd
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT: }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @foo spec_id(5) = 1. : f32
+  spv.SpecConstant @foo spec_id(5) = 1. : f32
 
   spv.func @use_foo() -> (f32) "None" {
     %0 = spv.mlir.referenceof @foo : f32
     spv.ReturnValue %0 : f32
   }
 }
 
 spv.module Logical GLSL450 {
-  spv.specConstant @bar spec_id(5) = 1. : f32
+  spv.SpecConstant @bar spec_id(5) = 1. : f32
 
   spv.func @use_bar() -> (f32) "None" {
     %0 = spv.mlir.referenceof @bar : f32
     %1 = spv.FAdd %0, %0 : f32
     spv.ReturnValue %1 : f32
   }
 }
 }
 
 // -----
 
 // CHECK:      module {
 // CHECK-NEXT:   spv.module Logical GLSL450 {
-// CHECK-NEXT:     spv.specConstant @bar spec_id(5)
+// CHECK-NEXT:     spv.SpecConstant @bar spec_id(5)
 
 // CHECK-NEXT:     spv.func @foo(%arg0: f32)
 // CHECK-NEXT:       spv.ReturnValue
 // CHECK-NEXT:     }
 
 // CHECK-NEXT:     spv.func @foo_different_body(%arg0: f32)
 // CHECK-NEXT:       spv.mlir.referenceof
 // CHECK-NEXT:       spv.ReturnValue

 // CHECK-NEXT:     spv.func @kernel_different_attr
 // CHECK-NEXT:       spv.Return
 // CHECK-NEXT:     }
 // CHECK-NEXT:   }
 // CHECK-NEXT:   }
 
 module {
 spv.module Logical GLSL450 {
-  spv.specConstant @bar spec_id(5) = 1. : f32
+  spv.SpecConstant @bar spec_id(5) = 1. : f32
 
   spv.func @foo(%arg0: f32) -> (f32) "None" {
     spv.ReturnValue %arg0 : f32
   }
 
   spv.func @foo_duplicate(%arg0: f32) -> (f32) "None" {
     spv.ReturnValue %arg0 : f32
   }

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

spv.func @cmpf(%arg0 : f32, %arg1 : f32) "None" {
     %16 = spv.IsInf %arg1 : f32
     spv.Return
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
-  spv.specConstant @condition_scalar = true
+  spv.SpecConstant @condition_scalar = true
   spv.func @select() -> () "None" {
     %0 = spv.constant 4.0 : f32
     %1 = spv.constant 5.0 : f32
     %2 = spv.mlir.referenceof @condition_scalar : i1
     // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, f32
     %3 = spv.Select %2, %0, %1 : i1, f32
     %4 = spv.constant dense<[2.0, 3.0, 4.0, 5.0]> : vector<4xf32>
     %5 = spv.constant dense<[6.0, 7.0, 8.0, 9.0]> : vector<4xf32>
     // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : i1, vector<4xf32>
     %6 = spv.Select %2, %4, %5 : i1, vector<4xf32>
     %7 = spv.constant dense<[true, true, true, true]> : vector<4xi1>
     // CHECK: spv.Select {{.*}}, {{.*}}, {{.*}} : vector<4xi1>, vector<4xf32>
     %8 = spv.Select %7, %4, %5 : vector<4xi1>, vector<4xf32>
     spv.Return
   }
 }

mlir/test/Target/SPIRV/spec-constant.mlir

 // RUN: mlir-translate -test-spirv-roundtrip -split-input-file %s | FileCheck %s
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
-  // CHECK: spv.specConstant @sc_true = true
-  spv.specConstant @sc_true = true
-  // CHECK: spv.specConstant @sc_false spec_id(1) = false
-  spv.specConstant @sc_false spec_id(1) = false
+  // CHECK: spv.SpecConstant @sc_true = true
+  spv.SpecConstant @sc_true = true
+  // CHECK: spv.SpecConstant @sc_false spec_id(1) = false
+  spv.SpecConstant @sc_false spec_id(1) = false
 
-  // CHECK: spv.specConstant @sc_int = -5 : i32
-  spv.specConstant @sc_int = -5 : i32
+  // CHECK: spv.SpecConstant @sc_int = -5 : i32
+  spv.SpecConstant @sc_int = -5 : i32
 
-  // CHECK: spv.specConstant @sc_float spec_id(5) = 1.000000e+00 : f32
-  spv.specConstant @sc_float spec_id(5) = 1. : f32
+  // CHECK: spv.SpecConstant @sc_float spec_id(5) = 1.000000e+00 : f32
+  spv.SpecConstant @sc_float spec_id(5) = 1. : f32
 
-  // CHECK: spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
-  spv.specConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
+  // CHECK: spv.SpecConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
+  spv.SpecConstantComposite @scc (@sc_int, @sc_int) : !spv.array<2 x i32>
 
   // CHECK-LABEL: @use
   spv.func @use() -> (i32) "None" {
     // We materialize a `spv.mlir.referenceof` op at every use of a
     // specialization constant in the deserializer. So two ops here.
     // CHECK: %[[USE1:.*]] = spv.mlir.referenceof @sc_int : i32
     // CHECK: %[[USE2:.*]] = spv.mlir.referenceof @sc_int : i32
     // CHECK: spv.IAdd %[[USE1]], %[[USE2]]
spv.func @use_composite() -> (i32) "None" {
     spv.ReturnValue %3 : i32
   }
 }
 
 // -----
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
 
-  spv.specConstant @sc_f32_1 = 1.5 : f32
-  spv.specConstant @sc_f32_2 = 2.5 : f32
-  spv.specConstant @sc_f32_3 = 3.5 : f32
+  spv.SpecConstant @sc_f32_1 = 1.5 : f32
+  spv.SpecConstant @sc_f32_2 = 2.5 : f32
+  spv.SpecConstant @sc_f32_3 = 3.5 : f32
 
-  spv.specConstant @sc_i32_1 = 1   : i32
+  spv.SpecConstant @sc_i32_1 = 1   : i32
 
-  // CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
-  spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
+  // CHECK: spv.SpecConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
+  spv.SpecConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
 
-  // CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
-  spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
+  // CHECK: spv.SpecConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
+  spv.SpecConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
 
-  // CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
-  spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
+  // CHECK: spv.SpecConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
+  spv.SpecConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
 }
 
 // -----
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
 
-  spv.specConstant @sc_f32_1 = 1.5 : f32
-  spv.specConstant @sc_f32_2 = 2.5 : f32
-  spv.specConstant @sc_f32_3 = 3.5 : f32
+  spv.SpecConstant @sc_f32_1 = 1.5 : f32
+  spv.SpecConstant @sc_f32_2 = 2.5 : f32
+  spv.SpecConstant @sc_f32_3 = 3.5 : f32
 
-  spv.specConstant @sc_i32_1 = 1   : i32
+  spv.SpecConstant @sc_i32_1 = 1   : i32
 
-  // CHECK: spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
-  spv.specConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
+  // CHECK: spv.SpecConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
+  spv.SpecConstantComposite @scc_array (@sc_f32_1, @sc_f32_2, @sc_f32_3) : !spv.array<3 x f32>
 
-  // CHECK: spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
-  spv.specConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
+  // CHECK: spv.SpecConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
+  spv.SpecConstantComposite @scc_struct (@sc_i32_1, @sc_f32_2, @sc_f32_3) : !spv.struct<(i32, f32, f32)>
 
-  // CHECK: spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
-  spv.specConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
+  // CHECK: spv.SpecConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3xf32>
+  spv.SpecConstantComposite @scc_vector (@sc_f32_1, @sc_f32_2, @sc_f32_3) : vector<3 x f32>
 }
 
 // -----
 
 spv.module Logical GLSL450 requires #spv.vce<v1.0, [Shader], []> {
 
-  spv.specConstant @sc_i32_1 = 1 : i32
+  spv.SpecConstant @sc_i32_1 = 1 : i32
 
   spv.func @use_composite() -> (i32) "None" {
     // CHECK: [[USE1:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32
     // CHECK: [[USE2:%.*]] = spv.constant 0 : i32
 
     // CHECK: [[RES1:%.*]] = spv.SpecConstantOperation wraps "spv.ISub"([[USE1]], [[USE2]]) : (i32, i32) -> i32
 
     // CHECK: [[USE3:%.*]] = spv.mlir.referenceof @sc_i32_1 : i32