[mlir][spirv] Add utilities for push constant value

[antiagainst]

Summary

This commit add utility functions for creating push constant
storage variable and loading values from it.

Along the way, performs some clean up:

• Deleted setABIAttrs, which is just a 4-liner function with one user.
• Moved SPIRVConverstionTarget into mlir namespace, to be consistent with SPIRVTypeConverter and LLVMConversionTarget.

[antiagainst]

These utility functions has been used in IREE for a while. Upstream them now.

mlir/docs/Dialects/SPIR-V.md

 ```
 
 The attribute has a few fields:
 
 *   Descriptor set number for the corresponding resource variable.
 *   Binding number for the corresponding resource variable.
 *   Storage class for the corresponding resource variable.
 
-The SPIR-V dialect provides a [`LowerABIAttributesPass`][MlirSpirvPasses] for
-consuming these attributes and create SPIR-V module complying with the
-interface.
+The SPIR-V dialect provides a [`LowerABIAttributesPass`][MlirSpirvPasses] that
+uses this information to lower the entry point function and its ABI consistent
+with the Vulkan validation rules. Specifically,
+
+*   Creates `spv.GlobalVariable`s for the arguments, and replaces all uses of
+    the argument with this variable. The SSA value used for replacement is
+    obtained using the `spv.mlir.addressof` operation.
+*   Adds the `spv.EntryPoint` and `spv.ExecutionMode` operations into the
+    `spv.module` for the entry function.
 
 ## Serialization and deserialization
 
 Although the main objective of the SPIR-V dialect is to act as a proper IR for
 compiler transformations, being able to serialize to and deserialize from the
 binary format is still very valuable for many good reasons. Serialization
 enables the artifacts of SPIR-V compilation to be consumed by an execution
 environment; deserialization allows us to import SPIR-V binary modules and run

 
 [Standard memref types][MlirMemrefType] with static shape and stride are
 converted to `spv.ptr<spv.struct<spv.array<...>>>`s. The resultant SPIR-V array
 types have the same element type as the source memref and its number of elements
 is obtained from the layout specification of the memref. The storage class of
 the pointer type are derived from the memref's memory space with
 `SPIRVTypeConverter::getStorageClassForMemorySpace()`.
 
-### `SPIRVOpLowering`
-
-`mlir::SPIRVOpLowering` is a base class that can be used to define the patterns
-used for implementing the lowering. For now this only provides derived classes
-access to an instance of `mlir::SPIRVTypeLowering` class.
-
 ### Utility functions for lowering
 
-#### Setting shader interface
-
-The method `mlir::spirv::setABIAttrs` allows setting the [shader interface
-attributes](#shader-interface-abi) for a function that is to be an entry
-point function within the `spv.module` on lowering. A later pass
-`mlir::spirv::LowerABIAttributesPass` uses this information to lower the entry
-point function and its ABI consistent with the Vulkan validation
-rules. Specifically,
-
-*   Creates `spv.GlobalVariable`s for the arguments, and replaces all uses of
-    the argument with this variable. The SSA value used for replacement is
-    obtained using the `spv.mlir.addressof` operation.
-*   Adds the `spv.EntryPoint` and `spv.ExecutionMode` operations into the
-    `spv.module` for the entry function.
-
 #### Setting layout for shader interface variables
 
 SPIR-V validation rules for shaders require composite objects to be explicitly
 laid out. If a `spv.GlobalVariable` is not explicitly laid out, the utility
 method `mlir::spirv::decorateType` implements a layout consistent with
 the [Vulkan shader requirements][VulkanShaderInterface].
 
 #### Creating builtin variables

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

 #include "mlir/Dialect/SPIRV/IR/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/ADT/SmallSet.h"
 
 namespace mlir {
 
+//===----------------------------------------------------------------------===//
+// Type Converter
+//===----------------------------------------------------------------------===//
+
 /// Type conversion from builtin types to SPIR-V types for shader interface.
 ///
 /// Non-32-bit scalar types require special hardware support that may not exist
 /// on all GPUs. This is reflected in SPIR-V as that non-32-bit scalar types
 /// require special capabilities or extensions. Right now if a scalar type of a
 /// certain bitwidth is not supported in the target environment, we use 32-bit
 /// ones unconditionally. This requires the runtime to also feed in data with
 /// a matched bitwidth and layout for interface types. The runtime can do that
public:
   /// llvm::None if the memory space does not map to any SPIR-V storage class.
   static Optional<spirv::StorageClass>
   getStorageClassForMemorySpace(unsigned space);
 
 private:
   spirv::TargetEnv targetEnv;
 };
 
-/// Appends to a pattern list additional patterns for translating the builtin
-/// `func` op to the SPIR-V dialect. These patterns do not handle shader
-/// interface/ABI; they convert function parameters to be of SPIR-V allowed
-/// types.
-void populateBuiltinFuncToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
-                                        RewritePatternSet &patterns);
-
-namespace spirv {
-class AccessChainOp;
-class FuncOp;
+//===----------------------------------------------------------------------===//
+// Conversion Target
+//===----------------------------------------------------------------------===//
 
+// The default SPIR-V conversion target.
+//
+// It takes a SPIR-V target environment and controls operation legality based on
+// the their availability in the target environment.
 class SPIRVConversionTarget : public ConversionTarget {
 public:
   /// Creates a SPIR-V conversion target for the given target environment.
-  static std::unique_ptr<SPIRVConversionTarget> get(TargetEnvAttr targetAttr);
+  static std::unique_ptr<SPIRVConversionTarget>
+  get(spirv::TargetEnvAttr targetAttr);
 
 private:
-  explicit SPIRVConversionTarget(TargetEnvAttr targetAttr);
+  explicit SPIRVConversionTarget(spirv::TargetEnvAttr targetAttr);
 
   // Be explicit that instance of this class cannot be copied or moved: there
   // are lambdas capturing fields of the instance.
   SPIRVConversionTarget(const SPIRVConversionTarget &) = delete;
   SPIRVConversionTarget(SPIRVConversionTarget &&) = delete;
   SPIRVConversionTarget &operator=(const SPIRVConversionTarget &) = delete;
   SPIRVConversionTarget &operator=(SPIRVConversionTarget &&) = delete;
 
   /// Returns true if the given `op` is legal to use under the current target
   /// environment.
   bool isLegalOp(Operation *op);
 
-  TargetEnv targetEnv;
+  spirv::TargetEnv targetEnv;
 };
 
+//===----------------------------------------------------------------------===//
+// Patterns and Utility Functions
+//===----------------------------------------------------------------------===//
+
+/// Appends to a pattern list additional patterns for translating the builtin
+/// `func` op to the SPIR-V dialect. These patterns do not handle shader
+/// interface/ABI; they convert function parameters to be of SPIR-V allowed
+/// types.
+void populateBuiltinFuncToSPIRVPatterns(SPIRVTypeConverter &typeConverter,
+                                        RewritePatternSet &patterns);
+
+namespace spirv {
+class AccessChainOp;
+
 /// Returns the value for the given `builtin` variable. This function gets or
 /// inserts the global variable associated for the builtin within the nearest
-/// enclosing op that has a symbol table. Returns null Value if such an
-/// enclosing op cannot be found.
+/// symbol table enclosing `op`. Returns null Value on error.
 Value getBuiltinVariableValue(Operation *op, BuiltIn builtin,
                               OpBuilder &builder);
 
+/// Gets the value at the given `offset` of the push constant storage with a
+/// total of `elementCount` 32-bit integers. A global variable will be created
+/// in the nearest symbol table enclosing `op` for the push constant storage if
+/// not existing. Load ops will be created via the given `builder` to load
+/// values from the push constant. Returns null Value on error.
+Value getPushConstantValue(Operation *op, unsigned elementCount,
+                           unsigned offset, OpBuilder &builder);
+
 /// Generates IR to perform index linearization with the given `indices` and
 /// their corresponding `strides`, adding an initial `offset`.
 Value linearizeIndex(ValueRange indices, ArrayRef<int64_t> strides,
                      int64_t offset, Location loc, OpBuilder &builder);
 
 /// Performs the index computation to get to the element at `indices` of the
 /// memory pointed to by `basePtr`, using the layout map of `baseType`.
 
 // TODO: This method assumes that the `baseType` is a MemRefType with AffineMap
 // that has static strides. Extend to handle dynamic strides.
 spirv::AccessChainOp getElementPtr(SPIRVTypeConverter &typeConverter,
                                    MemRefType baseType, Value basePtr,
                                    ValueRange indices, Location loc,
                                    OpBuilder &builder);
 
-/// Sets the InterfaceVarABIAttr and EntryPointABIAttr for a function and its
-/// arguments.
-LogicalResult setABIAttrs(spirv::FuncOp funcOp,
-                          EntryPointABIAttr entryPointInfo,
-                          ArrayRef<InterfaceVarABIAttr> argABIInfo);
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_SPIRVCONVERSION_H

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

lowerAsEntryFunction(gpu::GPUFuncOp funcOp, TypeConverter &typeConverter,
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), typeConverter,
                                          &signatureConverter)))
     return nullptr;
   rewriter.eraseOp(funcOp);
 
-  if (failed(spirv::setABIAttrs(newFuncOp, entryPointInfo, argABIInfo)))
-    return nullptr;
+  // Set the attributes for argument and the function.
+  StringRef argABIAttrName = spirv::getInterfaceVarABIAttrName();
+  for (auto argIndex : llvm::seq<unsigned>(0, argABIInfo.size())) {
+    newFuncOp.setArgAttr(argIndex, argABIAttrName, argABIInfo[argIndex]);
+  }
+  newFuncOp->setAttr(spirv::getEntryPointABIAttrName(), entryPointInfo);
+
   return newFuncOp;
 }
 
 /// Populates `argABI` with spv.interface_var_abi attributes for lowering
 /// gpu.func to spv.func if no arguments have the attributes set
 /// already. Returns failure if any argument has the ABI attribute set already.
 static LogicalResult
 getDefaultABIAttrs(MLIRContext *context, gpu::GPUFuncOp funcOp,

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRVPass.cpp

module.walk([&builder, &kernelModules](gpu::GPUModuleOp moduleOp) {
     // requirement here), clone the module for conversion because the
     // gpu.launch function still needs the kernel module.
     builder.setInsertionPoint(moduleOp.getOperation());
     kernelModules.push_back(builder.clone(*moduleOp.getOperation()));
   });
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
-      spirv::SPIRVConversionTarget::get(targetAttr);
+      SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   RewritePatternSet patterns(context);
   populateGPUToSPIRVPatterns(typeConverter, patterns);
   populateStandardToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyFullConversion(kernelModules, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertGPUToSPIRVPass() {
   return std::make_unique<GPUToSPIRVPass>();
 }

mlir/lib/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.cpp

 } // namespace
 
 void LinalgToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
-      spirv::SPIRVConversionTarget::get(targetAttr);
+      SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   RewritePatternSet patterns(context);
   populateLinalgToSPIRVPatterns(typeConverter, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   // Allow builtin ops.
   target->addLegalOp<ModuleOp>();

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRVPass.cpp

 } // namespace
 
 void SCFToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
-      spirv::SPIRVConversionTarget::get(targetAttr);
+      SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   ScfToSPIRVContext scfContext;
   RewritePatternSet patterns(context);
   populateSCFToSPIRVPatterns(typeConverter, scfContext, patterns);
   populateStandardToSPIRVPatterns(typeConverter, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(module, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>> mlir::createConvertSCFToSPIRVPass() {
   return std::make_unique<SCFToSPIRVPass>();
 }

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRVPass.cpp

 } // namespace
 
 void ConvertStandardToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
-      spirv::SPIRVConversionTarget::get(targetAttr);
+      SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   RewritePatternSet patterns(context);
   populateStandardToSPIRVPatterns(typeConverter, patterns);
   populateTensorToSPIRVPatterns(typeConverter,
                                 /*byteCountThreshold=*/64, patterns);
   populateBuiltinFuncToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(module, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertStandardToSPIRVPass() {
   return std::make_unique<ConvertStandardToSPIRVPass>();
 }

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRVPass.cpp

 } // namespace
 
 void LowerVectorToSPIRVPass::runOnOperation() {
   MLIRContext *context = &getContext();
   ModuleOp module = getOperation();
 
   auto targetAttr = spirv::lookupTargetEnvOrDefault(module);
   std::unique_ptr<ConversionTarget> target =
-      spirv::SPIRVConversionTarget::get(targetAttr);
+      SPIRVConversionTarget::get(targetAttr);
 
   SPIRVTypeConverter typeConverter(targetAttr);
   RewritePatternSet patterns(context);
   populateVectorToSPIRVPatterns(typeConverter, patterns);
 
   target->addLegalOp<ModuleOp>();
   target->addLegalOp<FuncOp>();
 
   if (failed(applyFullConversion(module, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<ModuleOp>>
 mlir::createConvertVectorToSPIRVPass() {
   return std::make_unique<LowerVectorToSPIRVPass>();
 }

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

if (t.isa<spirv::ScalarType>()) {
     // be used with logical addressing operations, not physical, and only with
     // non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
     // Private, Function, Input, and Output."
     if (bitWidth == 1) {
       return llvm::None;
     }
     return bitWidth / 8;
   }
+
   if (auto vecType = t.dyn_cast<VectorType>()) {
     auto elementSize = getTypeNumBytes(vecType.getElementType());
     if (!elementSize)
       return llvm::None;
     return vecType.getNumElements() * *elementSize;
   }
+
   if (auto memRefType = t.dyn_cast<MemRefType>()) {
     // TODO: Layout should also be controlled by the ABI attributes. For now
     // using the layout from MemRef.
     int64_t offset;
     SmallVector<int64_t, 4> strides;
     if (!memRefType.hasStaticShape() ||
         failed(getStridesAndOffset(memRefType, strides, offset))) {
       return llvm::None;
if (llvm::is_contained(dims, ShapedType::kDynamicSize) ||
         llvm::is_contained(strides, MemRefType::getDynamicStrideOrOffset())) {
       return llvm::None;
     }
     int64_t memrefSize = -1;
     for (auto shape : enumerate(dims)) {
       memrefSize = std::max(memrefSize, shape.value() * strides[shape.index()]);
     }
     return (offset + memrefSize) * elementSize.getValue();
-  } else if (auto tensorType = t.dyn_cast<TensorType>()) {
+  }
+
+  if (auto tensorType = t.dyn_cast<TensorType>()) {
     if (!tensorType.hasStaticShape()) {
       return llvm::None;
     }
     auto elementSize = getTypeNumBytes(tensorType.getElementType());
     if (!elementSize) {
       return llvm::None;
     }
     int64_t size = elementSize.getValue();
     for (auto shape : tensorType.getShape()) {
       size *= shape;
     }
     return size;
   }
+
   // TODO: Add size computation for other types.
   return llvm::None;
 }
 
 Optional<int64_t> SPIRVTypeConverter::getConvertedTypeNumBytes(Type t) {
   return getTypeNumBytes(t);
 }
 
Value mlir::spirv::getBuiltinVariableValue(Operation *op,
 
   spirv::GlobalVariableOp varOp = getOrInsertBuiltinVariable(
       *parent->getRegion(0).begin(), op->getLoc(), builtin, builder);
   Value ptr = builder.create<spirv::AddressOfOp>(op->getLoc(), varOp);
   return builder.create<spirv::LoadOp>(op->getLoc(), ptr);
 }
 
 //===----------------------------------------------------------------------===//
+// Push constant storage
+//===----------------------------------------------------------------------===//
+
+/// Returns the pointer type for the push constant storage containing
+/// `elementCount` 32-bit integer values.
+static spirv::PointerType getPushConstantStorageType(unsigned elementCount,
+                                                     Builder &builder) {
+  auto arrayType = spirv::ArrayType::get(
+      SPIRVTypeConverter::getIndexType(builder.getContext()), elementCount,
+      /*stride=*/4);
+  auto structType = spirv::StructType::get({arrayType}, /*offsetInfo=*/0);
+  return spirv::PointerType::get(structType, spirv::StorageClass::PushConstant);
+}
+
+/// Returns the push constant varible containing `elementCount` 32-bit integer
+/// values in `body`. Returns null op if such an op does not exit.
+static spirv::GlobalVariableOp getPushConstantVariable(Block &body,
+                                                       unsigned elementCount) {
+  for (auto varOp : body.getOps<spirv::GlobalVariableOp>()) {
+    auto ptrType = varOp.type().cast<spirv::PointerType>();
+    // Note that Vulkan requires "There must be no more than one push constant
+    // block statically used per shader entry point." So we should always reuse
+    // the existing one.
+    if (ptrType.getStorageClass() == spirv::StorageClass::PushConstant) {
+      auto numElements = ptrType.getPointeeType()
+                             .cast<spirv::StructType>()
+                             .getElementType(0)
+                             .cast<spirv::ArrayType>()
+                             .getNumElements();
+      if (numElements == elementCount)
+        return varOp;
+    }
+  }
+  return nullptr;
+}
+
+/// Gets or inserts a global variable for push constant storage containing
+/// `elementCount` 32-bit integer values in `block`.
+static spirv::GlobalVariableOp
+getOrInsertPushConstantVariable(Location loc, Block &block,
+                                unsigned elementCount, OpBuilder &b) {
+  if (auto varOp = getPushConstantVariable(block, elementCount))
+    return varOp;
+
+  auto builder = OpBuilder::atBlockBegin(&block, b.getListener());
+  auto type = getPushConstantStorageType(elementCount, builder);
+  const char *name = "__push_constant_var__";
+  return builder.create<spirv::GlobalVariableOp>(loc, type, name,
+                                                 /*initializer=*/nullptr);
+}
+
+Value spirv::getPushConstantValue(Operation *op, unsigned elementCount,
+                                  unsigned offset, OpBuilder &builder) {
+  Location loc = op->getLoc();
+  Operation *parent = SymbolTable::getNearestSymbolTable(op->getParentOp());
+  if (!parent) {
+    op->emitError("expected operation to be within a module-like op");
+    return nullptr;
+  }
+
+  spirv::GlobalVariableOp varOp = getOrInsertPushConstantVariable(
+      loc, parent->getRegion(0).front(), elementCount, builder);
+
+  auto i32Type = SPIRVTypeConverter::getIndexType(builder.getContext());
+  Value zeroOp = spirv::ConstantOp::getZero(i32Type, loc, builder);
+  Value offsetOp = builder.create<spirv::ConstantOp>(
+      loc, i32Type, builder.getI32IntegerAttr(offset));
+  auto addrOp = builder.create<spirv::AddressOfOp>(loc, varOp);
+  auto acOp = builder.create<spirv::AccessChainOp>(
+      loc, addrOp, llvm::makeArrayRef({zeroOp, offsetOp}));
+  return builder.create<spirv::LoadOp>(loc, acOp);
+}
+
+//===----------------------------------------------------------------------===//
 // Index calculation
 //===----------------------------------------------------------------------===//
 
 Value mlir::spirv::linearizeIndex(ValueRange indices, ArrayRef<int64_t> strides,
                                   int64_t offset, Location loc,
                                   OpBuilder &builder) {
   assert(indices.size() == strides.size() &&
          "must provide indices for all dimensions");
spirv::AccessChainOp mlir::spirv::getElementPtr(
   } else {
     linearizedIndices.push_back(
         linearizeIndex(indices, strides, offset, loc, builder));
   }
   return builder.create<spirv::AccessChainOp>(loc, basePtr, linearizedIndices);
 }
 
 //===----------------------------------------------------------------------===//
-// Set ABI attributes for lowering entry functions.
-//===----------------------------------------------------------------------===//
-
-LogicalResult
-mlir::spirv::setABIAttrs(spirv::FuncOp funcOp,
-                         spirv::EntryPointABIAttr entryPointInfo,
-                         ArrayRef<spirv::InterfaceVarABIAttr> argABIInfo) {
-  // Set the attributes for argument and the function.
-  StringRef argABIAttrName = spirv::getInterfaceVarABIAttrName();
-  for (auto argIndex : llvm::seq<unsigned>(0, argABIInfo.size())) {
-    funcOp.setArgAttr(argIndex, argABIAttrName, argABIInfo[argIndex]);
-  }
-  funcOp->setAttr(spirv::getEntryPointABIAttrName(), entryPointInfo);
-  return success();
-}
-
-//===----------------------------------------------------------------------===//
 // SPIR-V ConversionTarget
 //===----------------------------------------------------------------------===//
 
-std::unique_ptr<spirv::SPIRVConversionTarget>
-spirv::SPIRVConversionTarget::get(spirv::TargetEnvAttr targetAttr) {
+std::unique_ptr<SPIRVConversionTarget>
+SPIRVConversionTarget::get(spirv::TargetEnvAttr targetAttr) {
   std::unique_ptr<SPIRVConversionTarget> target(
       // std::make_unique does not work here because the constructor is private.
       new SPIRVConversionTarget(targetAttr));
   SPIRVConversionTarget *targetPtr = target.get();
-  target->addDynamicallyLegalDialect<SPIRVDialect>(
+  target->addDynamicallyLegalDialect<spirv::SPIRVDialect>(
       // We need to capture the raw pointer here because it is stable:
       // target will be destroyed once this function is returned.
       [targetPtr](Operation *op) { return targetPtr->isLegalOp(op); });
   return target;
 }
 
-spirv::SPIRVConversionTarget::SPIRVConversionTarget(
-    spirv::TargetEnvAttr targetAttr)
+SPIRVConversionTarget::SPIRVConversionTarget(spirv::TargetEnvAttr targetAttr)
     : ConversionTarget(*targetAttr.getContext()), targetEnv(targetAttr) {}
 
-bool spirv::SPIRVConversionTarget::isLegalOp(Operation *op) {
+bool SPIRVConversionTarget::isLegalOp(Operation *op) {
   // Make sure this op is available at the given version. Ops not implementing
   // QueryMinVersionInterface/QueryMaxVersionInterface are available to all
   // SPIR-V versions.
   if (auto minVersion = dyn_cast<spirv::QueryMinVersionInterface>(op))
     if (minVersion.getMinVersion() > this->targetEnv.getVersion()) {
       LLVM_DEBUG(llvm::dbgs()
                  << op->getName() << " illegal: requiring min version "
                  << spirv::stringifyVersion(minVersion.getMinVersion())

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

void ConvertToTargetEnv::runOnFunction() {
   auto targetEnv = fn.getOperation()
                        ->getAttr(spirv::getTargetEnvAttrName())
                        .cast<spirv::TargetEnvAttr>();
   if (!targetEnv) {
     fn.emitError("missing 'spv.target_env' attribute");
     return signalPassFailure();
   }
 
-  auto target = spirv::SPIRVConversionTarget::get(targetEnv);
+  auto target = SPIRVConversionTarget::get(targetEnv);
 
   RewritePatternSet patterns(context);
   patterns.add<ConvertToAtomCmpExchangeWeak, ConvertToBitReverse,
                ConvertToGroupNonUniformBallot, ConvertToModule,
                ConvertToSubgroupBallot>(context);
 
   if (failed(applyPartialConversion(fn, *target, std::move(patterns))))
     return signalPassFailure();