[mlir][spirv] Expose more query APIs directly on TargetEnv

[antiagainst]

Summary

This allows us to omit one level of indirection when querying
the information from the underlying attribute.

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

public:
   static TargetEnvAttr get(VerCapExtAttr triple, Vendor vendorID,
                            DeviceType deviceType, uint32_t deviceId,
                            DictionaryAttr limits);
 
   /// Returns the attribute kind's name (without the 'spv.' prefix).
   static StringRef getKindName();
 
   /// Returns the (version, capabilities, extensions) triple attribute.
-  VerCapExtAttr getTripleAttr();
+  VerCapExtAttr getTripleAttr() const;
 
   /// Returns the target version.
-  Version getVersion();
+  Version getVersion() const;
 
   /// Returns the target extensions.
   VerCapExtAttr::ext_range getExtensions();
   /// Returns the target extensions as a string array attribute.
   ArrayAttr getExtensionsAttr();
 
   /// Returns the target capabilities.
   VerCapExtAttr::cap_range getCapabilities();
   /// Returns the target capabilities as an integer array attribute.
   ArrayAttr getCapabilitiesAttr();
 
   /// Returns the vendor ID.
-  Vendor getVendorID();
+  Vendor getVendorID() const;
 
   /// Returns the device type.
-  DeviceType getDeviceType();
+  DeviceType getDeviceType() const;
 
   /// Returns the device ID.
-  uint32_t getDeviceID();
+  uint32_t getDeviceID() const;
 
   /// Returns the target resource limits.
-  ResourceLimitsAttr getResourceLimits();
+  ResourceLimitsAttr getResourceLimits() const;
 
   static LogicalResult
   verifyConstructionInvariants(Location loc, VerCapExtAttr triple,
                                Vendor vendorID, DeviceType deviceType,
                                uint32_t deviceID, DictionaryAttr limits);
 };
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H

mlir/include/mlir/Dialect/SPIRV/TargetAndABI.h

 enum class StorageClass : uint32_t;
 
 /// A wrapper class around a spirv::TargetEnvAttr to provide query methods for
 /// allowed version/capabilities/extensions.
 class TargetEnv {
 public:
   explicit TargetEnv(TargetEnvAttr targetAttr);
 
-  Version getVersion();
+  Version getVersion() const;
 
   /// Returns true if the given capability is allowed.
   bool allows(Capability) const;
   /// Returns the first allowed one if any of the given capabilities is allowed.
   /// Returns llvm::None otherwise.
   Optional<Capability> allows(ArrayRef<Capability>) const;
 
   /// Returns true if the given extension is allowed.
   bool allows(Extension) const;
   /// Returns the first allowed one if any of the given extensions is allowed.
   /// Returns llvm::None otherwise.
   Optional<Extension> allows(ArrayRef<Extension>) const;
 
+  /// Returns the vendor ID.
+  Vendor getVendorID() const;
+
+  /// Returns the device type.
+  DeviceType getDeviceType() const;
+
+  /// Returns the device ID.
+  uint32_t getDeviceID() const;
+
   /// Returns the MLIRContext.
   MLIRContext *getContext() const;
 
+  /// Returns the target resource limits.
+  ResourceLimitsAttr getResourceLimits() const;
+
+  TargetEnvAttr getAttr() const { return targetAttr; }
+
   /// Allows implicity converting to the underlying spirv::TargetEnvAttr.
   operator TargetEnvAttr() const { return targetAttr; }
 
 private:
   TargetEnvAttr targetAttr;
   llvm::SmallSet<Extension, 4> givenExtensions;    /// Allowed extensions
   llvm::SmallSet<Capability, 8> givenCapabilities; /// Allowed capabilities
 };

mlir/lib/Dialect/SPIRV/SPIRVAttributes.cpp

spirv::TargetEnvAttr spirv::TargetEnvAttr::get(spirv::VerCapExtAttr triple,
                                                DictionaryAttr limits) {
   assert(triple && limits && "expected valid triple and limits");
   MLIRContext *context = triple.getContext();
   return Base::get(context, triple, vendorID, deviceType, deviceID, limits);
 }
 
 StringRef spirv::TargetEnvAttr::getKindName() { return "target_env"; }
 
-spirv::VerCapExtAttr spirv::TargetEnvAttr::getTripleAttr() {
+spirv::VerCapExtAttr spirv::TargetEnvAttr::getTripleAttr() const {
   return getImpl()->triple.cast<spirv::VerCapExtAttr>();
 }
 
-spirv::Version spirv::TargetEnvAttr::getVersion() {
+spirv::Version spirv::TargetEnvAttr::getVersion() const {
   return getTripleAttr().getVersion();
 }
 
 spirv::VerCapExtAttr::ext_range spirv::TargetEnvAttr::getExtensions() {
   return getTripleAttr().getExtensions();
 }
 
 ArrayAttr spirv::TargetEnvAttr::getExtensionsAttr() {
   return getTripleAttr().getExtensionsAttr();
 }
 
 spirv::VerCapExtAttr::cap_range spirv::TargetEnvAttr::getCapabilities() {
   return getTripleAttr().getCapabilities();
 }
 
 ArrayAttr spirv::TargetEnvAttr::getCapabilitiesAttr() {
   return getTripleAttr().getCapabilitiesAttr();
 }
 
-spirv::Vendor spirv::TargetEnvAttr::getVendorID() {
+spirv::Vendor spirv::TargetEnvAttr::getVendorID() const {
   return getImpl()->vendorID;
 }
 
-spirv::DeviceType spirv::TargetEnvAttr::getDeviceType() {
+spirv::DeviceType spirv::TargetEnvAttr::getDeviceType() const {
   return getImpl()->deviceType;
 }
 
-uint32_t spirv::TargetEnvAttr::getDeviceID() { return getImpl()->deviceID; }
+uint32_t spirv::TargetEnvAttr::getDeviceID() const {
+  return getImpl()->deviceID;
+}
 
-spirv::ResourceLimitsAttr spirv::TargetEnvAttr::getResourceLimits() {
+spirv::ResourceLimitsAttr spirv::TargetEnvAttr::getResourceLimits() const {
   return getImpl()->limits.cast<spirv::ResourceLimitsAttr>();
 }
 
 LogicalResult spirv::TargetEnvAttr::verifyConstructionInvariants(
     Location loc, spirv::VerCapExtAttr /*triple*/, spirv::Vendor /*vendorID*/,
     spirv::DeviceType /*deviceType*/, uint32_t /*deviceID*/,
     DictionaryAttr limits) {
   if (!limits.isa<spirv::ResourceLimitsAttr>())
     return emitError(loc, "expected spirv::ResourceLimitsAttr for limits");
 
   return success();
 }

mlir/lib/Dialect/SPIRV/TargetAndABI.cpp

for (spirv::Capability cap : targetAttr.getCapabilities()) {
     givenCapabilities.insert(cap);
 
     // Add capabilities implied by the current capability.
     for (spirv::Capability c : spirv::getRecursiveImpliedCapabilities(cap))
       givenCapabilities.insert(c);
   }
 }
 
-spirv::Version spirv::TargetEnv::getVersion() {
+spirv::Version spirv::TargetEnv::getVersion() const {
   return targetAttr.getVersion();
 }
 
 bool spirv::TargetEnv::allows(spirv::Capability capability) const {
   return givenCapabilities.count(capability);
 }
 
 Optional<spirv::Capability>
 spirv::TargetEnv::allows(ArrayRef<spirv::Capability> caps) const {
-  auto chosen = llvm::find_if(caps, [this](spirv::Capability cap) {
+  const auto *chosen = llvm::find_if(caps, [this](spirv::Capability cap) {
     return givenCapabilities.count(cap);
   });
   if (chosen != caps.end())
     return *chosen;
   return llvm::None;
 }
 
 bool spirv::TargetEnv::allows(spirv::Extension extension) const {
   return givenExtensions.count(extension);
 }
 
 Optional<spirv::Extension>
 spirv::TargetEnv::allows(ArrayRef<spirv::Extension> exts) const {
-  auto chosen = llvm::find_if(exts, [this](spirv::Extension ext) {
+  const auto *chosen = llvm::find_if(exts, [this](spirv::Extension ext) {
     return givenExtensions.count(ext);
   });
   if (chosen != exts.end())
     return *chosen;
   return llvm::None;
 }
 
+spirv::Vendor spirv::TargetEnv::getVendorID() const {
+  return targetAttr.getVendorID();
+}
+
+spirv::DeviceType spirv::TargetEnv::getDeviceType() const {
+  return targetAttr.getDeviceType();
+}
+
+uint32_t spirv::TargetEnv::getDeviceID() const {
+  return targetAttr.getDeviceID();
+}
+
+spirv::ResourceLimitsAttr spirv::TargetEnv::getResourceLimits() const {
+  return targetAttr.getResourceLimits();
+}
+
 MLIRContext *spirv::TargetEnv::getContext() const {
   return targetAttr.getContext();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions
 //===----------------------------------------------------------------------===//