[mlir][spirv] Add get() method to TargetEnvAttr taking raw values

[antiagainst]

Summary

Also make the getResourceLimits() method more explicit about its return type.

[mravishankar]

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

58

Can we deprecate this one. I dont see a point of that anymore..

[antiagainst]

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

58

It might still be useful when we have extensions already packed as ArryAttr from somewhere else. Let's keep it for now.

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

 /// target environment.
 class TargetEnvAttr
     : public Attribute::AttrBase<TargetEnvAttr, Attribute,
                                  detail::TargetEnvAttributeStorage> {
 public:
   using Base::Base;
 
   /// Gets a TargetEnvAttr instance.
+  static TargetEnvAttr get(Version version, ArrayRef<Extension> extensions,
+                           ArrayRef<Capability> capabilities,
+                           DictionaryAttr limits);
   static TargetEnvAttr get(IntegerAttr version, ArrayAttr extensions,
                            ArrayAttr capabilities, DictionaryAttr limits);
 
   /// Returns the attribute kind's name (without the 'spv.' prefix).
   static StringRef getKindName();
 
   /// Returns the target version.
   Version getVersion();
 
public:
   using cap_range = llvm::iterator_range<cap_iterator>;
 
   /// Returns the target capabilities.
   cap_range getCapabilities();
   /// Returns the target capabilities as an integer array attribute.
   ArrayAttr getCapabilitiesAttr();
 
   /// Returns the target resource limits.
-  DictionaryAttr getResourceLimits();
+  ResourceLimitsAttr getResourceLimits();
 
   static bool kindof(unsigned kind) { return kind == AttrKind::TargetEnv; }
 
   static LogicalResult verifyConstructionInvariants(Location loc,
                                                     IntegerAttr version,
                                                     ArrayAttr extensions,
                                                     ArrayAttr capabilities,
                                                     DictionaryAttr limits);

mlir/lib/Dialect/SPIRV/TargetAndABI.cpp

struct TargetEnvAttributeStorage : public AttributeStorage {
   Attribute extensions;
   Attribute capabilities;
   Attribute limits;
 };
 } // namespace detail
 } // namespace spirv
 } // namespace mlir
 
+spirv::TargetEnvAttr spirv::TargetEnvAttr::get(
+    spirv::Version version, ArrayRef<spirv::Extension> extensions,
+    ArrayRef<spirv::Capability> capabilities, DictionaryAttr limits) {
+  Builder b(limits.getContext());
+
+  auto versionAttr = b.getI32IntegerAttr(static_cast<uint32_t>(version));
+
+  SmallVector<Attribute, 4> extAttrs;
+  extAttrs.reserve(extensions.size());
+  for (spirv::Extension ext : extensions)
+    extAttrs.push_back(b.getStringAttr(spirv::stringifyExtension(ext)));
+
+  SmallVector<Attribute, 4> capAttrs;
+  capAttrs.reserve(capabilities.size());
+  for (spirv::Capability cap : capabilities)
+    capAttrs.push_back(b.getI32IntegerAttr(static_cast<uint32_t>(cap)));
+
+  return get(versionAttr, b.getArrayAttr(extAttrs), b.getArrayAttr(capAttrs),
+             limits);
+}
+
 spirv::TargetEnvAttr spirv::TargetEnvAttr::get(IntegerAttr version,
                                                ArrayAttr extensions,
                                                ArrayAttr capabilities,
                                                DictionaryAttr limits) {
   assert(version && extensions && capabilities && limits);
   MLIRContext *context = version.getContext();
   return Base::get(context, spirv::AttrKind::TargetEnv, version, extensions,
                    capabilities, limits);
spirv::TargetEnvAttr::cap_range spirv::TargetEnvAttr::getCapabilities() {
   auto range = getCapabilitiesAttr().getValue();
   return {cap_iterator(range.begin()), cap_iterator(range.end())};
 }
 
 ArrayAttr spirv::TargetEnvAttr::getCapabilitiesAttr() {
   return getImpl()->capabilities.cast<ArrayAttr>();
 }
 
-DictionaryAttr spirv::TargetEnvAttr::getResourceLimits() {
-  return getImpl()->limits.cast<DictionaryAttr>();
+spirv::ResourceLimitsAttr spirv::TargetEnvAttr::getResourceLimits() {
+  return getImpl()->limits.cast<spirv::ResourceLimitsAttr>();
 }
 
 LogicalResult spirv::TargetEnvAttr::verifyConstructionInvariants(
     Location loc, IntegerAttr version, ArrayAttr extensions,
     ArrayAttr capabilities, DictionaryAttr limits) {
   if (!version.getType().isSignlessInteger(32))
     return emitError(loc, "expected 32-bit integer for version");