[mlir] Refactor ElementsAttr's value access API

[rriddle]

Summary

There are several aspects of the API that either aren't easy to use, or are
deceptively easy to do the wrong thing. The main change of this commit
is to remove all of the getValue<T>/getFlatValue<T> from ElementsAttr
and instead provide operator[] methods on the ranges returned by
getValues<T>. This provides a much more convenient API for the value
ranges. It also removes the easy-to-be-inefficient nature of
getValue/getFlatValue, which under the hood would construct a new range for
the type T. Constructing a range is not necessarily cheap in all cases, and
could lead to very poor performance if used within a loop; i.e. if you were to
naively write something like:

DenseElementsAttr attr = ...;
for (int i = 0; i < size; ++i) {
  // We are internally rebuilding the APFloat value range on each iteration!!
  APFloat it = attr.getFlatValue<APFloat>(i);
}

mlir/include/mlir/IR/BuiltinAttributeInterfaces.h

public:
 
   /// Return the value at the current iterator position.
   T operator*() const { return indexer.at<T>(index); }
 
 private:
   ElementsAttrIndexer indexer;
   ptrdiff_t index;
 };
+
+/// This class provides iterator utilities for an ElementsAttr range.
+template <typename IteratorT>
+class ElementsAttrRange : public llvm::iterator_range<IteratorT> {
+public:
+  using reference = typename IteratorT::reference;
+
+  ElementsAttrRange(Type shapeType,
+                    const llvm::iterator_range<IteratorT> &range)
+      : llvm::iterator_range<IteratorT>(range), shapeType(shapeType) {}
+  ElementsAttrRange(Type shapeType, IteratorT beginIt, IteratorT endIt)
+      : ElementsAttrRange(shapeType, llvm::make_range(beginIt, endIt)) {}
+
+  /// Return the value at the given index.
+  reference operator[](ArrayRef<uint64_t> index) const;
+  reference operator[](uint64_t index) const {
+    return *std::next(this->begin(), index);
+  }
+
+  /// Return the size of this range.
+  size_t size() const { return llvm::size(*this); }
+
+private:
+  /// The shaped type of the parent ElementsAttr.
+  Type shapeType;
+};
+
 } // namespace detail
 
 //===----------------------------------------------------------------------===//
 // MemRefLayoutAttrInterface
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 

 
 #include "mlir/IR/BuiltinAttributeInterfaces.h.inc"
 
 //===----------------------------------------------------------------------===//
 // ElementsAttr
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
+namespace detail {
+/// Return the value at the given index.
+template <typename IteratorT>
+auto ElementsAttrRange<IteratorT>::operator[](ArrayRef<uint64_t> index) const
+    -> reference {
+  // Skip to the element corresponding to the flattened index.
+  return (*this)[ElementsAttr::getFlattenedIndex(shapeType, index)];
+}
+} // namespace detail
+
 /// Return the elements of this attribute as a value of type 'T'.
 template <typename T>
 auto ElementsAttr::value_begin() const -> DefaultValueCheckT<T, iterator<T>> {
   if (Optional<iterator<T>> iterator = try_value_begin<T>())
     return std::move(*iterator);
   llvm::errs()
       << "ElementsAttr does not provide iteration facilities for type `"
       << llvm::getTypeName<T>() << "`, see attribute: " << *this << "\n";

mlir/include/mlir/IR/BuiltinAttributeInterfaces.td

InterfaceMethod<[{
       all elements of the attribute are the same value.
     }], "bool", "isSplat", (ins), /*defaultImplementation=*/[{}], [{
         // By default, only check for a single element splat.
         return $_attr.getNumElements() == 1;
     }]>
   ];
 
   string ElementsAttrInterfaceAccessors = [{
-    /// Return the attribute value at the given index. The index is expected to
-    /// refer to a valid element.
-    Attribute getValue(ArrayRef<uint64_t> index) const {
-      return getValue<Attribute>(index);
-    }
-
-    /// Return the value of type 'T' at the given index, where 'T' corresponds
-    /// to an Attribute type.
-    template <typename T>
-    std::enable_if_t<!std::is_same<T, ::mlir::Attribute>::value &&
-                     std::is_base_of<T, ::mlir::Attribute>::value>
-    getValue(ArrayRef<uint64_t> index) const {
-      return getValue(index).template dyn_cast_or_null<T>();
-    }
-
-    /// Return the value of type 'T' at the given index.
-    template <typename T>
-    T getValue(ArrayRef<uint64_t> index) const {
-      return getFlatValue<T>(getFlattenedIndex(index));
-    }
-
     /// Return the number of elements held by this attribute.
     int64_t size() const { return getNumElements(); }
 
     /// Return if the attribute holds no elements.
     bool empty() const { return size() == 0; }
   }];
 
   let extraTraitClassDeclaration = [{
public:
     }
 
     /// Return the elements of this attribute as a value of type 'T'.
     template <typename T>
     auto getValues() const {
       auto beginIt = $_attr.template value_begin<T>();
       return llvm::make_range(beginIt, std::next(beginIt, size()));
     }
-    /// Return the value at the given flattened index.
-    template <typename T> T getFlatValue(uint64_t index) const {
-      return *std::next($_attr.template value_begin<T>(), index);
-    }
   }] # ElementsAttrInterfaceAccessors;
 
   let extraClassDeclaration = [{
     template <typename T>
     using iterator = detail::ElementsAttrIterator<T>;
     template <typename T>
-    using iterator_range = llvm::iterator_range<iterator<T>>;
+    using iterator_range = detail::ElementsAttrRange<iterator<T>>;
 
     //===------------------------------------------------------------------===//
     // Accessors
     //===------------------------------------------------------------------===//
 
     /// Return the type of this attribute.
     ShapedType getType() const;
 
     /// Return the element type of this ElementsAttr.
     Type getElementType() const { return getElementType(*this); }
     static Type getElementType(Attribute elementsAttr);
 
     /// Return if the given 'index' refers to a valid element in this attribute.
     bool isValidIndex(ArrayRef<uint64_t> index) const {
       return isValidIndex(*this, index);
     }
     static bool isValidIndex(ShapedType type, ArrayRef<uint64_t> index);
     static bool isValidIndex(Attribute elementsAttr, ArrayRef<uint64_t> index);
 
     /// Return the 1 dimensional flattened row-major index from the given
     /// multi-dimensional index.
     uint64_t getFlattenedIndex(ArrayRef<uint64_t> index) const {
       return getFlattenedIndex(*this, index);
     }
-    static uint64_t getFlattenedIndex(Attribute elementsAttr,
+    static uint64_t getFlattenedIndex(Type type,
                                       ArrayRef<uint64_t> index);
+    static uint64_t getFlattenedIndex(Attribute elementsAttr,
+                                      ArrayRef<uint64_t> index) {
+      return getFlattenedIndex(elementsAttr.getType(), index);
+    }
 
     /// Returns the number of elements held by this attribute.
     int64_t getNumElements() const { return getNumElements(*this); }
     static int64_t getNumElements(Attribute elementsAttr);
 
     //===------------------------------------------------------------------===//
     // Value Iteration
     //===------------------------------------------------------------------===//
 
     template <typename T>
     using DerivedAttrValueCheckT =
         typename std::enable_if_t<std::is_base_of<Attribute, T>::value &&
                                   !std::is_same<Attribute, T>::value>;
     template <typename T, typename ResultT>
     using DefaultValueCheckT =
         typename std::enable_if_t<std::is_same<Attribute, T>::value ||
                                   !std::is_base_of<Attribute, T>::value,
                                   ResultT>;
 
-    /// Return the element of this attribute at the given index as a value of
-    /// type 'T'.
-    template <typename T>
-    T getFlatValue(uint64_t index) const {
-      return *std::next(value_begin<T>(), index);
-    }
-
     /// Return the splat value for this attribute. This asserts that the
     /// attribute corresponds to a splat.
     template <typename T>
     T getSplatValue() const {
       assert(isSplat() && "expected splat attribute");
       return *value_begin<T>();
     }
 
     /// Return the elements of this attribute as a value of type 'T'.
     template <typename T>
     DefaultValueCheckT<T, iterator_range<T>> getValues() const {
-      return iterator_range<T>(value_begin<T>(), value_end<T>());
+      return {Attribute::getType(), value_begin<T>(), value_end<T>()};
     }
     template <typename T>
     DefaultValueCheckT<T, iterator<T>> value_begin() const;
     template <typename T>
     DefaultValueCheckT<T, iterator<T>> value_end() const {
       return iterator<T>({}, size());
     }
 
     /// Return the held element values a range of T, where T is a derived
     /// attribute type.
     template <typename T>
     using DerivedAttrValueIterator =
       llvm::mapped_iterator<iterator<Attribute>, T (*)(Attribute)>;
     template <typename T>
     using DerivedAttrValueIteratorRange =
-      llvm::iterator_range<DerivedAttrValueIterator<T>>;
+      detail::ElementsAttrRange<DerivedAttrValueIterator<T>>;
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     DerivedAttrValueIteratorRange<T> getValues() const {
       auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
-      return llvm::map_range(getValues<Attribute>(),
-                             static_cast<T (*)(Attribute)>(castFn));
+      return {Attribute::getType(), llvm::map_range(getValues<Attribute>(),
+                             static_cast<T (*)(Attribute)>(castFn))};
     }
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     DerivedAttrValueIterator<T> value_begin() const {
       return getValues<T>().begin();
     }
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     DerivedAttrValueIterator<T> value_end() const {
       return {value_end<Attribute>(), nullptr};
     }
 
     //===------------------------------------------------------------------===//
     // Failable Value Iteration
 
     /// If this attribute supports iterating over element values of type `T`,
     /// return the iterable range. Otherwise, return llvm::None.
     template <typename T>
     DefaultValueCheckT<T, Optional<iterator_range<T>>> tryGetValues() const {
-      if (Optional<iterator<T>> beginIt = try_value_begin<T>())
-        return iterator_range<T>(*beginIt, value_end<T>());
+      if (Optional<iterator<T>> beginIt = try_value_begin<T>()) {
+        return iterator_range<T>(Attribute::getType(), *beginIt,
+                                 value_end<T>());
+      }
       return llvm::None;
     }
     template <typename T>
     DefaultValueCheckT<T, Optional<iterator<T>>> try_value_begin() const;
 
     /// If this attribute supports iterating over element values of type `T`,
     /// return the iterable range. Otherwise, return llvm::None.
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     Optional<DerivedAttrValueIteratorRange<T>> tryGetValues() const {
-      auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
-      if (auto values = tryGetValues<Attribute>())
-        return llvm::map_range(*values, static_cast<T (*)(Attribute)>(castFn));
+      auto values = tryGetValues<Attribute>();
+      if (!values)
         return llvm::None;
+
+      auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
+      return DerivedAttrValueIteratorRange<T>(
+        Attribute::getType(),
+        llvm::map_range(*values, static_cast<T (*)(Attribute)>(castFn))
+      );
     }
     template <typename T, typename = DerivedAttrValueCheckT<T>>
     Optional<DerivedAttrValueIterator<T>> try_value_begin() const {
       if (auto values = tryGetValues<T>())
         return values->begin();
       return llvm::None;
     }
   }] # ElementsAttrInterfaceAccessors;

mlir/include/mlir/IR/BuiltinAttributes.h

public:
   /// identified as splats in the future.
   static bool isValidRawBuffer(ShapedType type, ArrayRef<char> rawBuffer,
                                bool &detectedSplat);
 
   //===--------------------------------------------------------------------===//
   // Iterators
   //===--------------------------------------------------------------------===//
 
+  /// The iterator range over the given iterator type T.
+  template <typename IteratorT>
+  using iterator_range_impl = detail::ElementsAttrRange<IteratorT>;
+
+  /// The iterator for the given element type T.
+  template <typename T, typename AttrT = DenseElementsAttr>
+  using iterator = decltype(std::declval<AttrT>().template value_begin<T>());
+  /// The iterator range over the given element T.
+  template <typename T, typename AttrT = DenseElementsAttr>
+  using iterator_range =
+      decltype(std::declval<AttrT>().template getValues<T>());
+
   /// A utility iterator that allows walking over the internal Attribute values
   /// of a DenseElementsAttr.
   class AttributeElementIterator
       : public llvm::indexed_accessor_iterator<AttributeElementIterator,
                                                const void *, Attribute,
                                                Attribute, Attribute> {
   public:
     /// Accesses the Attribute value at this iterator position.
public:
   //===--------------------------------------------------------------------===//
 
   /// Returns true if this attribute corresponds to a splat, i.e. if all element
   /// values are the same.
   bool isSplat() const;
 
   /// Return the splat value for this attribute. This asserts that the attribute
   /// corresponds to a splat.
-  Attribute getSplatValue() const { return getSplatValue<Attribute>(); }
   template <typename T>
   typename std::enable_if<!std::is_base_of<Attribute, T>::value ||
                               std::is_same<Attribute, T>::value,
                           T>::type
   getSplatValue() const {
     assert(isSplat() && "expected the attribute to be a splat");
     return *value_begin<T>();
   }
   /// Return the splat value for derived attribute element types.
   template <typename T>
   typename std::enable_if<std::is_base_of<Attribute, T>::value &&
                               !std::is_same<Attribute, T>::value,
                           T>::type
   getSplatValue() const {
-    return getSplatValue().template cast<T>();
-  }
-
-  /// Return the value at the given index. The 'index' is expected to refer to a
-  /// valid element.
-  Attribute getValue(ArrayRef<uint64_t> index) const {
-    return getValue<Attribute>(index);
-  }
-  template <typename T>
-  T getValue(ArrayRef<uint64_t> index) const {
-    // Skip to the element corresponding to the flattened index.
-    return getFlatValue<T>(ElementsAttr::getFlattenedIndex(*this, index));
-  }
-  /// Return the value at the given flattened index.
-  template <typename T> T getFlatValue(uint64_t index) const {
-    return *std::next(value_begin<T>(), index);
+    return getSplatValue<Attribute>().template cast<T>();
   }
 
   /// Return the held element values as a range of integer or floating-point
   /// values.
   template <typename T>
   using IntFloatValueTemplateCheckT =
       typename std::enable_if<(!std::is_same<T, bool>::value &&
                                std::numeric_limits<T>::is_integer) ||
                               is_valid_cpp_fp_type<T>::value>::type;
   template <typename T, typename = IntFloatValueTemplateCheckT<T>>
-  llvm::iterator_range<ElementIterator<T>> getValues() const {
+  iterator_range_impl<ElementIterator<T>> getValues() const {
     assert(isValidIntOrFloat(sizeof(T), std::numeric_limits<T>::is_integer,
                              std::numeric_limits<T>::is_signed));
     const char *rawData = getRawData().data();
     bool splat = isSplat();
-    return {ElementIterator<T>(rawData, splat, 0),
+    return {Attribute::getType(), ElementIterator<T>(rawData, splat, 0),
             ElementIterator<T>(rawData, splat, getNumElements())};
   }
   template <typename T, typename = IntFloatValueTemplateCheckT<T>>
   ElementIterator<T> value_begin() const {
     assert(isValidIntOrFloat(sizeof(T), std::numeric_limits<T>::is_integer,
                              std::numeric_limits<T>::is_signed));
     return ElementIterator<T>(getRawData().data(), isSplat(), 0);
   }
   template <typename T, typename = IntFloatValueTemplateCheckT<T>>
   ElementIterator<T> value_end() const {
     assert(isValidIntOrFloat(sizeof(T), std::numeric_limits<T>::is_integer,
                              std::numeric_limits<T>::is_signed));
     return ElementIterator<T>(getRawData().data(), isSplat(), getNumElements());
   }
 
   /// Return the held element values as a range of std::complex.
   template <typename T, typename ElementT>
   using ComplexValueTemplateCheckT =
       typename std::enable_if<detail::is_complex_t<T>::value &&
                               (std::numeric_limits<ElementT>::is_integer ||
                                is_valid_cpp_fp_type<ElementT>::value)>::type;
   template <typename T, typename ElementT = typename T::value_type,
             typename = ComplexValueTemplateCheckT<T, ElementT>>
-  llvm::iterator_range<ElementIterator<T>> getValues() const {
+  iterator_range_impl<ElementIterator<T>> getValues() const {
     assert(isValidComplex(sizeof(T), std::numeric_limits<ElementT>::is_integer,
                           std::numeric_limits<ElementT>::is_signed));
     const char *rawData = getRawData().data();
     bool splat = isSplat();
-    return {ElementIterator<T>(rawData, splat, 0),
+    return {Attribute::getType(), ElementIterator<T>(rawData, splat, 0),
             ElementIterator<T>(rawData, splat, getNumElements())};
   }
   template <typename T, typename ElementT = typename T::value_type,
             typename = ComplexValueTemplateCheckT<T, ElementT>>
   ElementIterator<T> value_begin() const {
     assert(isValidComplex(sizeof(T), std::numeric_limits<ElementT>::is_integer,
                           std::numeric_limits<ElementT>::is_signed));
     return ElementIterator<T>(getRawData().data(), isSplat(), 0);
   }
   template <typename T, typename ElementT = typename T::value_type,
             typename = ComplexValueTemplateCheckT<T, ElementT>>
   ElementIterator<T> value_end() const {
     assert(isValidComplex(sizeof(T), std::numeric_limits<ElementT>::is_integer,
                           std::numeric_limits<ElementT>::is_signed));
     return ElementIterator<T>(getRawData().data(), isSplat(), getNumElements());
   }
 
   /// Return the held element values as a range of StringRef.
   template <typename T>
   using StringRefValueTemplateCheckT =
       typename std::enable_if<std::is_same<T, StringRef>::value>::type;
   template <typename T, typename = StringRefValueTemplateCheckT<T>>
-  llvm::iterator_range<ElementIterator<StringRef>> getValues() const {
+  iterator_range_impl<ElementIterator<StringRef>> getValues() const {
     auto stringRefs = getRawStringData();
     const char *ptr = reinterpret_cast<const char *>(stringRefs.data());
     bool splat = isSplat();
-    return {ElementIterator<StringRef>(ptr, splat, 0),
+    return {Attribute::getType(), ElementIterator<StringRef>(ptr, splat, 0),
             ElementIterator<StringRef>(ptr, splat, getNumElements())};
   }
   template <typename T, typename = StringRefValueTemplateCheckT<T>>
   ElementIterator<StringRef> value_begin() const {
     const char *ptr = reinterpret_cast<const char *>(getRawStringData().data());
     return ElementIterator<StringRef>(ptr, isSplat(), 0);
   }
   template <typename T, typename = StringRefValueTemplateCheckT<T>>
   ElementIterator<StringRef> value_end() const {
     const char *ptr = reinterpret_cast<const char *>(getRawStringData().data());
     return ElementIterator<StringRef>(ptr, isSplat(), getNumElements());
   }
 
   /// Return the held element values as a range of Attributes.
   template <typename T>
   using AttributeValueTemplateCheckT =
       typename std::enable_if<std::is_same<T, Attribute>::value>::type;
   template <typename T, typename = AttributeValueTemplateCheckT<T>>
-  llvm::iterator_range<AttributeElementIterator> getValues() const {
-    return {value_begin<Attribute>(), value_end<Attribute>()};
+  iterator_range_impl<AttributeElementIterator> getValues() const {
+    return {Attribute::getType(), value_begin<Attribute>(),
+            value_end<Attribute>()};
   }
   template <typename T, typename = AttributeValueTemplateCheckT<T>>
   AttributeElementIterator value_begin() const {
     return AttributeElementIterator(*this, 0);
   }
   template <typename T, typename = AttributeValueTemplateCheckT<T>>
   AttributeElementIterator value_end() const {
     return AttributeElementIterator(*this, getNumElements());
   }
 
   /// Return the held element values a range of T, where T is a derived
   /// attribute type.
   template <typename T>
   using DerivedAttrValueTemplateCheckT =
       typename std::enable_if<std::is_base_of<Attribute, T>::value &&
                               !std::is_same<Attribute, T>::value>::type;
   template <typename T>
   using DerivedAttributeElementIterator =
       llvm::mapped_iterator<AttributeElementIterator, T (*)(Attribute)>;
   template <typename T, typename = DerivedAttrValueTemplateCheckT<T>>
-  llvm::iterator_range<DerivedAttributeElementIterator<T>> getValues() const {
+  iterator_range_impl<DerivedAttributeElementIterator<T>> getValues() const {
     auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
-    return llvm::map_range(getValues<Attribute>(),
-                           static_cast<T (*)(Attribute)>(castFn));
+    return {Attribute::getType(),
+            llvm::map_range(getValues<Attribute>(),
+                            static_cast<T (*)(Attribute)>(castFn))};
   }
   template <typename T, typename = DerivedAttrValueTemplateCheckT<T>>
   DerivedAttributeElementIterator<T> value_begin() const {
     auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
     return {value_begin<Attribute>(), static_cast<T (*)(Attribute)>(castFn)};
   }
   template <typename T, typename = DerivedAttrValueTemplateCheckT<T>>
   DerivedAttributeElementIterator<T> value_end() const {
     auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
     return {value_end<Attribute>(), static_cast<T (*)(Attribute)>(castFn)};
   }
 
   /// Return the held element values as a range of bool. The element type of
   /// this attribute must be of integer type of bitwidth 1.
   template <typename T>
   using BoolValueTemplateCheckT =
       typename std::enable_if<std::is_same<T, bool>::value>::type;
   template <typename T, typename = BoolValueTemplateCheckT<T>>
-  llvm::iterator_range<BoolElementIterator> getValues() const {
+  iterator_range_impl<BoolElementIterator> getValues() const {
     assert(isValidBool() && "bool is not the value of this elements attribute");
-    return {BoolElementIterator(*this, 0),
+    return {Attribute::getType(), BoolElementIterator(*this, 0),
             BoolElementIterator(*this, getNumElements())};
   }
   template <typename T, typename = BoolValueTemplateCheckT<T>>
   BoolElementIterator value_begin() const {
     assert(isValidBool() && "bool is not the value of this elements attribute");
     return BoolElementIterator(*this, 0);
   }
   template <typename T, typename = BoolValueTemplateCheckT<T>>
   BoolElementIterator value_end() const {
     assert(isValidBool() && "bool is not the value of this elements attribute");
     return BoolElementIterator(*this, getNumElements());
   }
 
   /// Return the held element values as a range of APInts. The element type of
   /// this attribute must be of integer type.
   template <typename T>
   using APIntValueTemplateCheckT =
       typename std::enable_if<std::is_same<T, APInt>::value>::type;
   template <typename T, typename = APIntValueTemplateCheckT<T>>
-  llvm::iterator_range<IntElementIterator> getValues() const {
+  iterator_range_impl<IntElementIterator> getValues() const {
     assert(getElementType().isIntOrIndex() && "expected integral type");
-    return {raw_int_begin(), raw_int_end()};
+    return {Attribute::getType(), raw_int_begin(), raw_int_end()};
   }
   template <typename T, typename = APIntValueTemplateCheckT<T>>
   IntElementIterator value_begin() const {
     assert(getElementType().isIntOrIndex() && "expected integral type");
     return raw_int_begin();
   }
   template <typename T, typename = APIntValueTemplateCheckT<T>>
   IntElementIterator value_end() const {
     assert(getElementType().isIntOrIndex() && "expected integral type");
     return raw_int_end();
   }
 
   /// Return the held element values as a range of complex APInts. The element
   /// type of this attribute must be a complex of integer type.
   template <typename T>
   using ComplexAPIntValueTemplateCheckT = typename std::enable_if<
       std::is_same<T, std::complex<APInt>>::value>::type;
   template <typename T, typename = ComplexAPIntValueTemplateCheckT<T>>
-  llvm::iterator_range<ComplexIntElementIterator> getValues() const {
+  iterator_range_impl<ComplexIntElementIterator> getValues() const {
     return getComplexIntValues();
   }
   template <typename T, typename = ComplexAPIntValueTemplateCheckT<T>>
   ComplexIntElementIterator value_begin() const {
     return complex_value_begin();
   }
   template <typename T, typename = ComplexAPIntValueTemplateCheckT<T>>
   ComplexIntElementIterator value_end() const {
     return complex_value_end();
   }
 
   /// Return the held element values as a range of APFloat. The element type of
   /// this attribute must be of float type.
   template <typename T>
   using APFloatValueTemplateCheckT =
       typename std::enable_if<std::is_same<T, APFloat>::value>::type;
   template <typename T, typename = APFloatValueTemplateCheckT<T>>
-  llvm::iterator_range<FloatElementIterator> getValues() const {
+  iterator_range_impl<FloatElementIterator> getValues() const {
     return getFloatValues();
   }
   template <typename T, typename = APFloatValueTemplateCheckT<T>>
   FloatElementIterator value_begin() const {
     return float_value_begin();
   }
   template <typename T, typename = APFloatValueTemplateCheckT<T>>
   FloatElementIterator value_end() const {
     return float_value_end();
   }
 
   /// Return the held element values as a range of complex APFloat. The element
   /// type of this attribute must be a complex of float type.
   template <typename T>
   using ComplexAPFloatValueTemplateCheckT = typename std::enable_if<
       std::is_same<T, std::complex<APFloat>>::value>::type;
   template <typename T, typename = ComplexAPFloatValueTemplateCheckT<T>>
-  llvm::iterator_range<ComplexFloatElementIterator> getValues() const {
+  iterator_range_impl<ComplexFloatElementIterator> getValues() const {
     return getComplexFloatValues();
   }
   template <typename T, typename = ComplexAPFloatValueTemplateCheckT<T>>
   ComplexFloatElementIterator value_begin() const {
     return complex_float_value_begin();
   }
   template <typename T, typename = ComplexAPFloatValueTemplateCheckT<T>>
   ComplexFloatElementIterator value_end() const {
protected:
   /// are hidden from the user to encourage consistent use of the
   /// getValues/value_begin/value_end API.
   IntElementIterator raw_int_begin() const {
     return IntElementIterator(*this, 0);
   }
   IntElementIterator raw_int_end() const {
     return IntElementIterator(*this, getNumElements());
   }
-  llvm::iterator_range<ComplexIntElementIterator> getComplexIntValues() const;
+  iterator_range_impl<ComplexIntElementIterator> getComplexIntValues() const;
   ComplexIntElementIterator complex_value_begin() const;
   ComplexIntElementIterator complex_value_end() const;
-  llvm::iterator_range<FloatElementIterator> getFloatValues() const;
+  iterator_range_impl<FloatElementIterator> getFloatValues() const;
   FloatElementIterator float_value_begin() const;
   FloatElementIterator float_value_end() const;
-  llvm::iterator_range<ComplexFloatElementIterator>
+  iterator_range_impl<ComplexFloatElementIterator>
   getComplexFloatValues() const;
   ComplexFloatElementIterator complex_float_value_begin() const;
   ComplexFloatElementIterator complex_float_value_end() const;
 
   /// Overload of the raw 'get' method that asserts that the given type is of
   /// complex type. This method is used to verify type invariants that the
   /// templatized 'get' method cannot.
   static DenseElementsAttr getRawComplex(ShapedType type, ArrayRef<char> data,
public:
   static bool classof(Attribute attr);
 };
 
 //===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
 template <typename T>
-auto SparseElementsAttr::getValues() const
-    -> llvm::iterator_range<iterator<T>> {
+auto SparseElementsAttr::value_begin() const -> iterator<T> {
   auto zeroValue = getZeroValue<T>();
   auto valueIt = getValues().value_begin<T>();
   const std::vector<ptrdiff_t> flatSparseIndices(getFlattenedSparseIndices());
   std::function<T(ptrdiff_t)> mapFn =
       [flatSparseIndices{std::move(flatSparseIndices)},
        valueIt{std::move(valueIt)},
        zeroValue{std::move(zeroValue)}](ptrdiff_t index) {
         // Try to map the current index to one of the sparse indices.
         for (unsigned i = 0, e = flatSparseIndices.size(); i != e; ++i)
           if (flatSparseIndices[i] == index)
             return *std::next(valueIt, i);
         // Otherwise, return the zero value.
         return zeroValue;
       };
-  return llvm::map_range(llvm::seq<ptrdiff_t>(0, getNumElements()), mapFn);
-}
-template <typename T>
-auto SparseElementsAttr::value_begin() const -> iterator<T> {
-  return getValues<T>().begin();
-}
-template <typename T>
-auto SparseElementsAttr::value_end() const -> iterator<T> {
-  return getValues<T>().end();
+  return iterator<T>(llvm::seq<ptrdiff_t>(0, getNumElements()).begin(), mapFn);
 }
 } // end namespace mlir.
 
 //===----------------------------------------------------------------------===//
 // Attribute Utilities
 //===----------------------------------------------------------------------===//
 
 namespace llvm {

mlir/include/mlir/IR/BuiltinAttributes.td

let description = [{
     // A tensor of 2 float32 elements.
     dense<[10.0, 11.0]> : tensor<2xf32>
     ```
   }];
   let parameters = (ins AttributeSelfTypeParameter<"", "ShapedType">:$type,
                         "ArrayRef<char>":$rawData);
   let extraClassDeclaration = [{
     using DenseElementsAttr::empty;
-    using DenseElementsAttr::getFlatValue;
     using DenseElementsAttr::getNumElements;
-    using DenseElementsAttr::getValue;
     using DenseElementsAttr::getValues;
     using DenseElementsAttr::isSplat;
     using DenseElementsAttr::size;
     using DenseElementsAttr::value_begin;
 
     /// The set of data types that can be iterated by this attribute.
     using ContiguousIterableTypesT = std::tuple<
       // Integer types.
let builders = [
     AttrBuilderWithInferredContext<(ins "ShapedType":$type,
                                         "ArrayRef<StringRef>":$values), [{
       return $_get(type.getContext(), type, values,
                    /* isSplat */(values.size() == 1));
     }]>,
   ];
   let extraClassDeclaration = [{
     using DenseElementsAttr::empty;
-    using DenseElementsAttr::getFlatValue;
     using DenseElementsAttr::getNumElements;
-    using DenseElementsAttr::getValue;
     using DenseElementsAttr::getValues;
     using DenseElementsAttr::isSplat;
     using DenseElementsAttr::size;
     using DenseElementsAttr::value_begin;
 
     /// The set of data types that can be iterated by this attribute.
     using ContiguousIterableTypesT = std::tuple<StringRef>;
     using NonContiguousIterableTypesT = std::tuple<Attribute>;
AttrBuilderWithInferredContext<(ins "Dialect *":$dialect,
       MLIRContext *ctxt = dialect->getContext();
       Identifier dialectName = Identifier::get(dialect->getNamespace(), ctxt);
       return $_get(ctxt, dialectName, value, type);
     }]>
   ];
   let extraClassDeclaration = [{
     using ValueType = StringRef;
 
-    /// Return the value at the given index. The 'index' is expected to refer to
-    /// a valid element.
-    Attribute getValue(ArrayRef<uint64_t> index) const;
-
     /// Decodes the attribute value using dialect-specific decoding hook.
     /// Returns false if decoding is successful. If not, returns true and leaves
     /// 'result' argument unspecified.
     bool decode(ElementsAttr &result);
   }];
   let genVerifyDecl = 1;
   let skipDefaultBuilders = 1;
 }
let extraClassDeclaration = [{
     template <typename T>
     using iterator =
         llvm::mapped_iterator<typename decltype(llvm::seq<ptrdiff_t>(0, 0))::iterator,
                               std::function<T(ptrdiff_t)>>;
 
     /// Return the values of this attribute in the form of the given type 'T'.
     /// 'T'  may be any of Attribute, APInt, APFloat, c++ integer/float types,
     /// etc.
-    template <typename T> llvm::iterator_range<iterator<T>> getValues() const;
     template <typename T> iterator<T> value_begin() const;
-    template <typename T> iterator<T> value_end() const;
-
-    /// Return the value of the element at the given index. The 'index' is
-    /// expected to refer to a valid element.
-    Attribute getValue(ArrayRef<uint64_t> index) const;
 
   private:
     /// Get a zero APFloat for the given sparse attribute.
     APFloat getZeroAPFloat() const;
 
     /// Get a zero APInt for the given sparse attribute.
     APInt getZeroAPInt() const;
 

mlir/include/mlir/IR/Matchers.h

if (!constant_op_binder<Attribute>(&attr).match(op))
       return false;
     auto type = op->getResult(0).getType();
 
     if (type.isa<IntegerType, IndexType>())
       return attr_value_binder<IntegerAttr>(bind_value).match(attr);
     if (type.isa<VectorType, RankedTensorType>()) {
       if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
         return attr_value_binder<IntegerAttr>(bind_value)
-            .match(splatAttr.getSplatValue());
+            .match(splatAttr.getSplatValue<Attribute>());
       }
     }
     return false;
   }
 };
 
 /// The matcher that matches a given target constant scalar / vector splat /
 /// tensor splat integer value.

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 //===----------------------------------------------------------------------===//
 
 bool mlirAttributeIsAElements(MlirAttribute attr) {
   return unwrap(attr).isa<ElementsAttr>();
 }
 
 MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                        uint64_t *idxs) {
-  return wrap(unwrap(attr).cast<ElementsAttr>().getValue(
-      llvm::makeArrayRef(idxs, rank)));
+  return wrap(unwrap(attr)
+                  .cast<ElementsAttr>()
+                  .getValues<Attribute>()[llvm::makeArrayRef(idxs, rank)]);
 }
 
 bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                   uint64_t *idxs) {
   return unwrap(attr).cast<ElementsAttr>().isValidIndex(
       llvm::makeArrayRef(idxs, rank));
 }
 

 //===----------------------------------------------------------------------===//
 // Splat accessors.
 
 bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().isSplat();
 }
 
 MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) {
-  return wrap(unwrap(attr).cast<DenseElementsAttr>().getSplatValue());
+  return wrap(
+      unwrap(attr).cast<DenseElementsAttr>().getSplatValue<Attribute>());
 }
 int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<bool>();
 }
 int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) {
   return unwrap(attr).cast<DenseElementsAttr>().getSplatValue<int8_t>();
 }
 uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) {
MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) {
   return wrap(
       unwrap(attr).cast<DenseElementsAttr>().getSplatValue<StringRef>());
 }
 
 //===----------------------------------------------------------------------===//
 // Indexed accessors.
 
 bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<bool>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<bool>()[pos];
 }
 int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<int8_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<int8_t>()[pos];
 }
 uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<uint8_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint8_t>()[pos];
 }
 int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<int32_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<int32_t>()[pos];
 }
 uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<uint32_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint32_t>()[pos];
 }
 int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<int64_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<int64_t>()[pos];
 }
 uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<uint64_t>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<uint64_t>()[pos];
 }
 float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<float>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<float>()[pos];
 }
 double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) {
-  return unwrap(attr).cast<DenseElementsAttr>().getFlatValue<double>(pos);
+  return unwrap(attr).cast<DenseElementsAttr>().getValues<double>()[pos];
 }
 MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                   intptr_t pos) {
   return wrap(
-      unwrap(attr).cast<DenseElementsAttr>().getFlatValue<StringRef>(pos));
+      unwrap(attr).cast<DenseElementsAttr>().getValues<StringRef>()[pos]);
 }
 
 //===----------------------------------------------------------------------===//
 // Raw data accessors.
 
 const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) {
   return static_cast<const void *>(
       unwrap(attr).cast<DenseElementsAttr>().getRawData().data());

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

 LogicalResult WorkGroupSizeConversion::matchAndRewrite(
     gpu::BlockDimOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto index = getLaunchConfigIndex(op);
   if (!index)
     return failure();
 
   auto workGroupSizeAttr = spirv::lookupLocalWorkGroupSize(op);
-  auto val = workGroupSizeAttr.getValue<int32_t>(index.getValue());
+  auto val = workGroupSizeAttr.getValues<int32_t>()[index.getValue()];
   auto convertedType =
       getTypeConverter()->convertType(op.getResult().getType());
   if (!convertedType)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::ConstantOp>(
       op, convertedType, IntegerAttr::get(convertedType, val));
   return success();
 }

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

matchAndRewrite(memref::GlobalOp global, OpAdaptor adaptor,
     Attribute initialValue = nullptr;
     if (!global.isExternal() && !global.isUninitialized()) {
       auto elementsAttr = global.initial_value()->cast<ElementsAttr>();
       initialValue = elementsAttr;
 
       // For scalar memrefs, the global variable created is of the element type,
       // so unpack the elements attribute to extract the value.
       if (type.getRank() == 0)
-        initialValue = elementsAttr.getValue({});
+        initialValue = elementsAttr.getSplatValue<Attribute>();
     }
 
     uint64_t alignment = global.alignment().getValueOr(0);
 
     auto newGlobal = rewriter.replaceOpWithNewOp<LLVM::GlobalOp>(
         global, arrayTy, global.constant(), linkage, global.sym_name(),
         initialValue, alignment, type.getMemorySpaceAsInt());
     if (!global.isExternal() && global.isUninitialized()) {

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

static void convertContractOp(vector::ContractionOp op,
   valueMapping[op.getResult()] = matmul;
 }
 
 /// Convert a 2D splat ConstantOp to a SubgroupMmaConstantMatrix op.
 static void convertConstantOp(arith::ConstantOp op,
                               llvm::DenseMap<Value, Value> &valueMapping) {
   assert(constantSupportsMMAMatrixType(op));
   OpBuilder b(op);
-  Attribute splat = op.getValue().cast<SplatElementsAttr>().getSplatValue();
+  Attribute splat =
+      op.getValue().cast<SplatElementsAttr>().getSplatValue<Attribute>();
   auto scalarConstant =
       b.create<arith::ConstantOp>(op.getLoc(), splat.getType(), splat);
   const char *fragType = inferFragType(op);
   auto vecType = op.getType().cast<VectorType>();
   gpu::MMAMatrixType type = gpu::MMAMatrixType::get(
       vecType.getShape(), vecType.getElementType(), llvm::StringRef(fragType));
   auto matrix = b.create<gpu::SubgroupMmaConstantMatrixOp>(op.getLoc(), type,
                                                            scalarConstant);

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

AffineParallelOp::operand_range AffineParallelOp::getLowerBoundsOperands() {
   return getOperands().take_front(lowerBoundsMap().getNumInputs());
 }
 
 AffineParallelOp::operand_range AffineParallelOp::getUpperBoundsOperands() {
   return getOperands().drop_front(lowerBoundsMap().getNumInputs());
 }
 
 AffineMap AffineParallelOp::getLowerBoundMap(unsigned pos) {
+  auto values = lowerBoundsGroups().getValues<int32_t>();
   unsigned start = 0;
   for (unsigned i = 0; i < pos; ++i)
-    start += lowerBoundsGroups().getValue<int32_t>(i);
-  return lowerBoundsMap().getSliceMap(
-      start, lowerBoundsGroups().getValue<int32_t>(pos));
+    start += values[i];
+  return lowerBoundsMap().getSliceMap(start, values[pos]);
 }
 
 AffineMap AffineParallelOp::getUpperBoundMap(unsigned pos) {
+  auto values = upperBoundsGroups().getValues<int32_t>();
   unsigned start = 0;
   for (unsigned i = 0; i < pos; ++i)
-    start += upperBoundsGroups().getValue<int32_t>(i);
-  return upperBoundsMap().getSliceMap(
-      start, upperBoundsGroups().getValue<int32_t>(pos));
+    start += values[i];
+  return upperBoundsMap().getSliceMap(start, values[pos]);
 }
 
 AffineValueMap AffineParallelOp::getLowerBoundsValueMap() {
   return AffineValueMap(lowerBoundsMap(), getLowerBoundsOperands());
 }
 
 AffineValueMap AffineParallelOp::getUpperBoundsValueMap() {
   return AffineValueMap(upperBoundsMap(), getUpperBoundsOperands());

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 }
 
 static bool isZeroAttribute(Attribute value) {
   if (auto intValue = value.dyn_cast<IntegerAttr>())
     return intValue.getValue().isNullValue();
   if (auto fpValue = value.dyn_cast<FloatAttr>())
     return fpValue.getValue().isZero();
   if (auto splatValue = value.dyn_cast<SplatElementsAttr>())
-    return isZeroAttribute(splatValue.getSplatValue());
+    return isZeroAttribute(splatValue.getSplatValue<Attribute>());
   if (auto elementsValue = value.dyn_cast<ElementsAttr>())
     return llvm::all_of(elementsValue.getValues<Attribute>(), isZeroAttribute);
   if (auto arrayValue = value.dyn_cast<ArrayAttr>())
     return llvm::all_of(arrayValue.getValue(), isZeroAttribute);
   return false;
 }
 
 static LogicalResult verify(GlobalOp op) {

mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp

 
 constexpr const static unsigned kDefaultPointerSizeBits = 64;
 constexpr const static unsigned kDefaultPointerAlignment = 8;
 constexpr const static unsigned kBitsInByte = 8;
 
 /// Returns the value that corresponds to named position `pos` from the
 /// attribute `attr` assuming it's a dense integer elements attribute.
 static unsigned extractPointerSpecValue(Attribute attr, DLEntryPos pos) {
-  return attr.cast<DenseIntElementsAttr>().getValue<unsigned>(
-      static_cast<unsigned>(pos));
+  return attr.cast<DenseIntElementsAttr>()
+      .getValues<unsigned>()[static_cast<unsigned>(pos)];
 }
 
 /// Returns the part of the data layout entry that corresponds to `pos` for the
 /// given `type` by interpreting the list of entries `params`. For the pointer
 /// type in the default address space, returns the default value if the entries
 /// do not provide a custom one, for other address spaces returns None.
 static Optional<unsigned>
 getPointerDataLayoutEntry(DataLayoutEntryListRef params, LLVMPointerType type,

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

for (OpOperand *opOperand : genericOp.getInputOperands()) {
       Operation *def = opOperand->get().getDefiningOp();
       Attribute constantAttr;
       auto isScalarOrSplatConstantOp = [&constantAttr](Operation *def) -> bool {
         {
           DenseElementsAttr splatAttr;
           if (matchPattern(def, m_Constant<DenseElementsAttr>(&splatAttr)) &&
               splatAttr.isSplat() &&
               splatAttr.getType().getElementType().isIntOrFloat()) {
-            constantAttr = splatAttr.getSplatValue();
+            constantAttr = splatAttr.getSplatValue<Attribute>();
             return true;
           }
         }
         {
           IntegerAttr intAttr;
           if (matchPattern(def, m_Constant<IntegerAttr>(&intAttr))) {
             constantAttr = intAttr;
             return true;
auto computeRemappedLinearIndex = [&](int linearIndex) {
         for (int i = 0; i < numInputs; ++i)
           srcLinearIndices[i] =
               srcLinearIndices[i] * inputShapes[i][dim] + srcIndices[i][dim];
       }
     };
 
     bool isFloat = elementType.isa<FloatType>();
     if (isFloat) {
-      SmallVector<iterator_range<DenseElementsAttr::FloatElementIterator>>
-          inputFpIterators;
+      SmallVector<DenseElementsAttr::iterator_range<APFloat>> inFpRanges;
       for (int i = 0; i < numInputs; ++i)
-        inputFpIterators.push_back(inputValues[i].getValues<APFloat>());
+        inFpRanges.push_back(inputValues[i].getValues<APFloat>());
 
       computeFnInputs.apFloats.resize(numInputs, APFloat(0.f));
 
       // Transpose the input constant. Because we don't know its rank in
       // advance, we need to loop over the range [0, element count) and
       // delinearize the index.
       for (int linearIndex = 0; linearIndex < numElements; ++linearIndex) {
         computeRemappedLinearIndex(linearIndex);
 
         // Collect constant elements for all inputs at this loop iteration.
-        for (int i = 0; i < numInputs; ++i) {
-          computeFnInputs.apFloats[i] =
-              *(inputFpIterators[i].begin() + srcLinearIndices[i]);
-        }
+        for (int i = 0; i < numInputs; ++i)
+          computeFnInputs.apFloats[i] = inFpRanges[i][srcLinearIndices[i]];
 
         // Invoke the computation to get the corresponding constant output
         // element.
-        APIntOrFloat outputs = computeFn(computeFnInputs);
-
-        fpOutputValues[dstLinearIndex] = outputs.apFloat.getValue();
+        fpOutputValues[dstLinearIndex] = *computeFn(computeFnInputs).apFloat;
       }
     } else {
-      SmallVector<iterator_range<DenseElementsAttr::IntElementIterator>>
-          inputIntIterators;
+      SmallVector<DenseElementsAttr::iterator_range<APInt>> inIntRanges;
       for (int i = 0; i < numInputs; ++i)
-        inputIntIterators.push_back(inputValues[i].getValues<APInt>());
+        inIntRanges.push_back(inputValues[i].getValues<APInt>());
 
       computeFnInputs.apInts.resize(numInputs);
 
       // Transpose the input constant. Because we don't know its rank in
       // advance, we need to loop over the range [0, element count) and
       // delinearize the index.
       for (int linearIndex = 0; linearIndex < numElements; ++linearIndex) {
         computeRemappedLinearIndex(linearIndex);
 
         // Collect constant elements for all inputs at this loop iteration.
-        for (int i = 0; i < numInputs; ++i) {
-          computeFnInputs.apInts[i] =
-              *(inputIntIterators[i].begin() + srcLinearIndices[i]);
-        }
+        for (int i = 0; i < numInputs; ++i)
+          computeFnInputs.apInts[i] = inIntRanges[i][srcLinearIndices[i]];
 
         // Invoke the computation to get the corresponding constant output
         // element.
-        APIntOrFloat outputs = computeFn(computeFnInputs);
-
-        intOutputValues[dstLinearIndex] = outputs.apInt.getValue();
+        intOutputValues[dstLinearIndex] = *computeFn(computeFnInputs).apInt;
       }
     }
 
-    DenseIntOrFPElementsAttr outputAttr;
-    if (isFloat) {
-      outputAttr = DenseFPElementsAttr::get(outputType, fpOutputValues);
-    } else {
-      outputAttr = DenseIntElementsAttr::get(outputType, intOutputValues);
-    }
+    DenseElementsAttr outputAttr =
+        isFloat ? DenseElementsAttr::get(outputType, fpOutputValues)
+                : DenseElementsAttr::get(outputType, intOutputValues);
+
     rewriter.replaceOpWithNewOp<ConstantOp>(genericOp, outputAttr);
     return success();
   }
 
 private:
   ControlElementwiseOpsFusionFn controlFn;
 };
 

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

static Attribute extractCompositeElement(Attribute composite,
   if (!composite)
     return {};
   // Return composite itself if we reach the end of the index chain.
   if (indices.empty())
     return composite;
 
   if (auto vector = composite.dyn_cast<ElementsAttr>()) {
     assert(indices.size() == 1 && "must have exactly one index for a vector");
-    return vector.getValue({indices[0]});
+    return vector.getValues<Attribute>()[indices[0]];
   }
 
   if (auto array = composite.dyn_cast<ArrayAttr>()) {
     assert(!indices.empty() && "must have at least one index for an array");
     return extractCompositeElement(array.getValue()[indices[0]],
                                    indices.drop_front());
   }
 

mlir/lib/Dialect/Shape/IR/Shape.cpp

OpFoldResult GetExtentOp::fold(ArrayRef<Attribute> operands) {
   auto elements = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
   if (!elements)
     return nullptr;
   Optional<int64_t> dim = getConstantDim();
   if (!dim.hasValue())
     return nullptr;
   if (dim.getValue() >= elements.getNumElements())
     return nullptr;
-  return elements.getValue({(uint64_t)dim.getValue()});
+  return elements.getValues<Attribute>()[(uint64_t)dim.getValue()];
 }
 
 void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape,
                         int64_t dim) {
   auto loc = result.location;
   auto dimAttr = builder.getIndexAttr(dim);
   if (shape.getType().isa<ShapeType>()) {
     Value dim = builder.create<ConstSizeOp>(loc, dimAttr);

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

static void printSwitchOpCases(
     DenseIntElementsAttr caseValues, SuccessorRange caseDestinations,
     OperandRangeRange caseOperands, TypeRangeRange caseOperandTypes) {
   p << "  default: ";
   p.printSuccessorAndUseList(defaultDestination, defaultOperands);
 
   if (!caseValues)
     return;
 
-  for (int64_t i = 0, size = caseValues.size(); i < size; ++i) {
+  for (const auto &it : llvm::enumerate(caseValues.getValues<APInt>())) {
     p << ',';
     p.printNewline();
     p << "  ";
-    p << caseValues.getValue<APInt>(i).getLimitedValue();
+    p << it.value().getLimitedValue();
     p << ": ";
-    p.printSuccessorAndUseList(caseDestinations[i], caseOperands[i]);
+    p.printSuccessorAndUseList(caseDestinations[it.index()],
+                               caseOperands[it.index()]);
   }
   p.printNewline();
 }
 
 static LogicalResult verify(SwitchOp op) {
   auto caseValues = op.getCaseValues();
   auto caseDestinations = op.getCaseDestinations();
 

 Block *SwitchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
   Optional<DenseIntElementsAttr> caseValues = getCaseValues();
 
   if (!caseValues)
     return getDefaultDestination();
 
   SuccessorRange caseDests = getCaseDestinations();
   if (auto value = operands.front().dyn_cast_or_null<IntegerAttr>()) {
-    for (int64_t i = 0, size = getCaseValues()->size(); i < size; ++i)
-      if (value == caseValues->getValue<IntegerAttr>(i))
-        return caseDests[i];
+    for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>()))
+      if (it.value() == value.getValue())
+        return caseDests[it.index()];
     return getDefaultDestination();
   }
   return nullptr;
 }
 
 /// switch %flag : i32, [
 ///   default:  ^bb1
 /// ]

 dropSwitchCasesThatMatchDefault(SwitchOp op, PatternRewriter &rewriter) {
   SmallVector<Block *> newCaseDestinations;
   SmallVector<ValueRange> newCaseOperands;
   SmallVector<APInt> newCaseValues;
   bool requiresChange = false;
   auto caseValues = op.getCaseValues();
   auto caseDests = op.getCaseDestinations();
 
-  for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
-    if (caseDests[i] == op.getDefaultDestination() &&
-        op.getCaseOperands(i) == op.getDefaultOperands()) {
+  for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
+    if (caseDests[it.index()] == op.getDefaultDestination() &&
+        op.getCaseOperands(it.index()) == op.getDefaultOperands()) {
       requiresChange = true;
       continue;
     }
-    newCaseDestinations.push_back(caseDests[i]);
-    newCaseOperands.push_back(op.getCaseOperands(i));
-    newCaseValues.push_back(caseValues->getValue<APInt>(i));
+    newCaseDestinations.push_back(caseDests[it.index()]);
+    newCaseOperands.push_back(op.getCaseOperands(it.index()));
+    newCaseValues.push_back(it.value());
   }
 
   if (!requiresChange)
     return failure();
 
   rewriter.replaceOpWithNewOp<SwitchOp>(
       op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
       newCaseValues, newCaseDestinations, newCaseOperands);
   return success();
 }
 
 /// Helper for folding a switch with a constant value.
 /// switch %c_42 : i32, [
 ///   default: ^bb1 ,
 ///   42: ^bb2,
 ///   43: ^bb3
 /// ]
 /// -> br ^bb2
 static void foldSwitch(SwitchOp op, PatternRewriter &rewriter,
                        APInt caseValue) {
   auto caseValues = op.getCaseValues();
-  for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
-    if (caseValues->getValue<APInt>(i) == caseValue) {
-      rewriter.replaceOpWithNewOp<BranchOp>(op, op.getCaseDestinations()[i],
-                                            op.getCaseOperands(i));
+  for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
+    if (it.value() == caseValue) {
+      rewriter.replaceOpWithNewOp<BranchOp>(
+          op, op.getCaseDestinations()[it.index()],
+          op.getCaseOperands(it.index()));
       return;
     }
   }
   rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
                                         op.getDefaultOperands());
 }
 
 /// switch %c_42 : i32, [
simplifySwitchFromSwitchOnSameCondition(SwitchOp op,
   // and that it branches on the same condition and that this branch isn't the
   // default destination.
   auto predSwitch = dyn_cast<SwitchOp>(predecessor->getTerminator());
   if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
       predSwitch.getDefaultDestination() == currentBlock)
     return failure();
 
   // Fold this switch to an unconditional branch.
-  APInt caseValue;
-  bool isDefault = true;
   SuccessorRange predDests = predSwitch.getCaseDestinations();
+  auto it = llvm::find(predDests, currentBlock);
+  if (it != predDests.end()) {
     Optional<DenseIntElementsAttr> predCaseValues = predSwitch.getCaseValues();
-  for (int64_t i = 0, size = predCaseValues->size(); i < size; ++i) {
-    if (currentBlock == predDests[i]) {
-      caseValue = predCaseValues->getValue<APInt>(i);
-      isDefault = false;
-      break;
-    }
-  }
-  if (isDefault)
+    foldSwitch(op, rewriter,
+               predCaseValues->getValues<APInt>()[it - predDests.begin()]);
+  } else {
     rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
                                           op.getDefaultOperands());
-  else
-    foldSwitch(op, rewriter, caseValue);
+  }
   return success();
 }
 
 /// switch %flag : i32, [
 ///   default: ^bb1,
 ///   42: ^bb2
 /// ]
 /// ^bb1:
if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
     return failure();
 
   // Delete case values that are not possible here.
   DenseSet<APInt> caseValuesToRemove;
   auto predDests = predSwitch.getCaseDestinations();
   auto predCaseValues = predSwitch.getCaseValues();
   for (int64_t i = 0, size = predCaseValues->size(); i < size; ++i)
     if (currentBlock != predDests[i])
-      caseValuesToRemove.insert(predCaseValues->getValue<APInt>(i));
+      caseValuesToRemove.insert(predCaseValues->getValues<APInt>()[i]);
 
   SmallVector<Block *> newCaseDestinations;
   SmallVector<ValueRange> newCaseOperands;
   SmallVector<APInt> newCaseValues;
   bool requiresChange = false;
 
   auto caseValues = op.getCaseValues();
   auto caseDests = op.getCaseDestinations();
-  for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
-    if (caseValuesToRemove.contains(caseValues->getValue<APInt>(i))) {
+  for (const auto &it : llvm::enumerate(caseValues->getValues<APInt>())) {
+    if (caseValuesToRemove.contains(it.value())) {
       requiresChange = true;
       continue;
     }
-    newCaseDestinations.push_back(caseDests[i]);
-    newCaseOperands.push_back(op.getCaseOperands(i));
-    newCaseValues.push_back(caseValues->getValue<APInt>(i));
+    newCaseDestinations.push_back(caseDests[it.index()]);
+    newCaseOperands.push_back(op.getCaseOperands(it.index()));
+    newCaseValues.push_back(it.value());
   }
 
   if (!requiresChange)
     return failure();
 
   rewriter.replaceOpWithNewOp<SwitchOp>(
       op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
       newCaseValues, newCaseDestinations, newCaseOperands);

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

 OpFoldResult ExtractOp::fold(ArrayRef<Attribute> operands) {
   // The tensor operand must be a known constant.
   Attribute tensor = operands.front();
   if (!tensor)
     return {};
   // If this is a splat elements attribute, simply return the value. All of the
   // elements of a splat attribute are the same.
   if (auto splatTensor = tensor.dyn_cast<SplatElementsAttr>())
-    return splatTensor.getSplatValue();
+    return splatTensor.getSplatValue<Attribute>();
 
   // Otherwise, collect the constant indices into the tensor.
   SmallVector<uint64_t, 8> indices;
   for (Attribute indice : llvm::drop_begin(operands, 1)) {
     if (!indice || !indice.isa<IntegerAttr>())
       return {};
     indices.push_back(indice.cast<IntegerAttr>().getInt());
   }
 
   // If this is an elements attribute, query the value at the given indices.
   auto elementsAttr = tensor.dyn_cast<ElementsAttr>();
   if (elementsAttr && elementsAttr.isValidIndex(indices))
-    return elementsAttr.getValue(indices);
+    return elementsAttr.getValues<Attribute>()[indices];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // FromElementsOp
 //===----------------------------------------------------------------------===//
 
 void FromElementsOp::build(OpBuilder &builder, OperationState &result,
static LogicalResult verify(InsertOp op) {
   return success();
 }
 
 OpFoldResult InsertOp::fold(ArrayRef<Attribute> operands) {
   Attribute scalar = operands[0];
   Attribute dest = operands[1];
   if (scalar && dest)
     if (auto splatDest = dest.dyn_cast<SplatElementsAttr>())
-      if (scalar == splatDest.getSplatValue())
+      if (scalar == splatDest.getSplatValue<Attribute>())
         return dest;
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // GenerateOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/Tosa/IR/TosaOps.cpp

LogicalResult matchAndRewrite(tosa::TransposeOp op,
     int64_t numElements = inputType.getNumElements();
 
     SmallVector<Attribute, 4> outputValues;
     outputValues.resize(numElements);
 
     // Transpose the input constant. Because we don't know its rank in advance,
     // we need to loop over the range [0, element count) and delinearize the
     // index.
+    auto attrValues = inputValues.getValues<Attribute>();
     for (int srcLinearIndex = 0; srcLinearIndex < numElements;
          ++srcLinearIndex) {
       SmallVector<uint64_t, 6> srcIndices(inputType.getRank(), 0);
       int totalCount = srcLinearIndex;
       for (int dim = inputType.getRank() - 1; dim >= 0; --dim) {
         srcIndices[dim] = totalCount % inputShape[dim];
         totalCount /= inputShape[dim];
       }
 
       SmallVector<uint64_t, 6> dstIndices(outputType.getRank(), 0);
       for (int dim = outputType.getRank() - 1; dim >= 0; --dim)
         dstIndices[dim] = srcIndices[permValues[dim]];
 
       uint64_t dstLinearIndex = dstIndices.front();
       for (int dim = 1; dim < outputType.getRank(); ++dim)
         dstLinearIndex = dstLinearIndex * outputShape[dim] + dstIndices[dim];
 
-      outputValues[dstLinearIndex] = inputValues.getValue(srcIndices);
+      outputValues[dstLinearIndex] = attrValues[srcIndices];
     }
 
     rewriter.replaceOpWithNewOp<tosa::ConstOp>(
         op, outputType, DenseElementsAttr::get(outputType, outputValues));
     return success();
   }
 };
 

mlir/lib/Dialect/Vector/VectorOps.cpp

OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
   if (getSourceType() == getVectorType())
     return source();
   if (!operands[0])
     return {};
   auto vectorType = getVectorType();
   if (operands[0].getType().isIntOrIndexOrFloat())
     return DenseElementsAttr::get(vectorType, operands[0]);
   if (auto attr = operands[0].dyn_cast<SplatElementsAttr>())
-    return DenseElementsAttr::get(vectorType, attr.getSplatValue());
+    return DenseElementsAttr::get(vectorType, attr.getSplatValue<Attribute>());
   return {};
 }
 
 namespace {
 
 // BroadcastOp can only add dimensions or broadcast a dimension from 1 to N. In
 // the degenerated case where the broadcast only adds dimensions of size 1 it
 // can be replaced by a ShapeCastOp. This canonicalization checks if the total
LogicalResult matchAndRewrite(ExtractStridedSliceOp extractStridedSliceOp,
     auto constantOp =
         extractStridedSliceOp.vector().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     auto newAttr = DenseElementsAttr::get(extractStridedSliceOp.getType(),
-                                          dense.getSplatValue());
+                                          dense.getSplatValue<Attribute>());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractStridedSliceOp,
                                                    newAttr);
     return success();
   }
 };
 
 // Pattern to rewrite an ExtractStridedSliceOp(BroadcastOp) to
 // BroadcastOp(ExtractStrideSliceOp).
LogicalResult matchAndRewrite(ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
     auto constantOp = shapeCastOp.source().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     // Only handle splat for now.
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
-    auto newAttr = DenseElementsAttr::get(
-        shapeCastOp.getType().cast<VectorType>(), dense.getSplatValue());
+    auto newAttr =
+        DenseElementsAttr::get(shapeCastOp.getType().cast<VectorType>(),
+                               dense.getSplatValue<Attribute>());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(shapeCastOp, newAttr);
     return success();
   }
 };
 
 } // namespace
 
 void ShapeCastOp::getCanonicalizationPatterns(RewritePatternSet &results,

mlir/lib/IR/BuiltinAttributeInterfaces.cpp

return llvm::all_of(llvm::seq<int>(0, rank), [&](int i) {
     return 0 <= dim && dim < shape[i];
   });
 }
 bool ElementsAttr::isValidIndex(Attribute elementsAttr,
                                 ArrayRef<uint64_t> index) {
   return isValidIndex(elementsAttr.getType().cast<ShapedType>(), index);
 }
 
-uint64_t ElementsAttr::getFlattenedIndex(Attribute elementsAttr,
-                                         ArrayRef<uint64_t> index) {
-  ShapedType type = elementsAttr.getType().cast<ShapedType>();
-  assert(isValidIndex(type, index) && "expected valid multi-dimensional index");
+uint64_t ElementsAttr::getFlattenedIndex(Type type, ArrayRef<uint64_t> index) {
+  ShapedType shapeType = type.cast<ShapedType>();
+  assert(isValidIndex(shapeType, index) &&
+         "expected valid multi-dimensional index");
 
   // Reduce the provided multidimensional index into a flattended 1D row-major
   // index.
-  auto rank = type.getRank();
-  auto shape = type.getShape();
+  auto rank = shapeType.getRank();
+  ArrayRef<int64_t> shape = shapeType.getShape();
   uint64_t valueIndex = 0;
   uint64_t dimMultiplier = 1;
   for (int i = rank - 1; i >= 0; --i) {
     valueIndex += index[i] * dimMultiplier;
     dimMultiplier *= shape[i];
   }
   return valueIndex;
 }

mlir/lib/IR/BuiltinAttributes.cpp

 }
 
 /// Return if the given complex type has an integer element type.
 static bool isComplexOfIntType(Type type) {
   return type.cast<ComplexType>().getElementType().isa<IntegerType>();
 }
 
 auto DenseElementsAttr::getComplexIntValues() const
-    -> llvm::iterator_range<ComplexIntElementIterator> {
+    -> iterator_range_impl<ComplexIntElementIterator> {
   assert(isComplexOfIntType(getElementType()) &&
          "expected complex integral type");
-  return {ComplexIntElementIterator(*this, 0),
+  return {getType(), ComplexIntElementIterator(*this, 0),
           ComplexIntElementIterator(*this, getNumElements())};
 }
 auto DenseElementsAttr::complex_value_begin() const
     -> ComplexIntElementIterator {
   assert(isComplexOfIntType(getElementType()) &&
          "expected complex integral type");
   return ComplexIntElementIterator(*this, 0);
 }
 auto DenseElementsAttr::complex_value_end() const -> ComplexIntElementIterator {
   assert(isComplexOfIntType(getElementType()) &&
          "expected complex integral type");
   return ComplexIntElementIterator(*this, getNumElements());
 }
 
 /// Return the held element values as a range of APFloat. The element type of
 /// this attribute must be of float type.
 auto DenseElementsAttr::getFloatValues() const
-    -> llvm::iterator_range<FloatElementIterator> {
+    -> iterator_range_impl<FloatElementIterator> {
   auto elementType = getElementType().cast<FloatType>();
   const auto &elementSemantics = elementType.getFloatSemantics();
-  return {FloatElementIterator(elementSemantics, raw_int_begin()),
+  return {getType(), FloatElementIterator(elementSemantics, raw_int_begin()),
           FloatElementIterator(elementSemantics, raw_int_end())};
 }
 auto DenseElementsAttr::float_value_begin() const -> FloatElementIterator {
   auto elementType = getElementType().cast<FloatType>();
   return FloatElementIterator(elementType.getFloatSemantics(), raw_int_begin());
 }
 auto DenseElementsAttr::float_value_end() const -> FloatElementIterator {
   auto elementType = getElementType().cast<FloatType>();
   return FloatElementIterator(elementType.getFloatSemantics(), raw_int_end());
 }
 
 auto DenseElementsAttr::getComplexFloatValues() const
-    -> llvm::iterator_range<ComplexFloatElementIterator> {
+    -> iterator_range_impl<ComplexFloatElementIterator> {
   Type eltTy = getElementType().cast<ComplexType>().getElementType();
   assert(eltTy.isa<FloatType>() && "expected complex float type");
   const auto &semantics = eltTy.cast<FloatType>().getFloatSemantics();
-  return {{semantics, {*this, 0}},
+  return {getType(),
+          {semantics, {*this, 0}},
           {semantics, {*this, static_cast<size_t>(getNumElements())}}};
 }
 auto DenseElementsAttr::complex_float_value_begin() const
     -> ComplexFloatElementIterator {
   Type eltTy = getElementType().cast<ComplexType>().getElementType();
   assert(eltTy.isa<FloatType>() && "expected complex float type");
   return {eltTy.cast<FloatType>().getFloatSemantics(), {*this, 0}};
 }
bool DenseIntElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseElementsAttr>() &&
          attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
 }
 
 //===----------------------------------------------------------------------===//
 // OpaqueElementsAttr
 //===----------------------------------------------------------------------===//
 
-/// Return the value at the given index. If index does not refer to a valid
-/// element, then a null attribute is returned.
-Attribute OpaqueElementsAttr::getValue(ArrayRef<uint64_t> index) const {
-  assert(isValidIndex(index) && "expected valid multi-dimensional index");
-  return Attribute();
-}
-
 bool OpaqueElementsAttr::decode(ElementsAttr &result) {
   Dialect *dialect = getDialect().getDialect();
   if (!dialect)
     return true;
   auto *interface =
       dialect->getRegisteredInterface<DialectDecodeAttributesInterface>();
   if (!interface)
     return true;
   return failed(interface->decode(*this, result));
 }
 
 LogicalResult
 OpaqueElementsAttr::verify(function_ref<InFlightDiagnostic()> emitError,
                            Identifier dialect, StringRef value,
                            ShapedType type) {
   if (!Dialect::isValidNamespace(dialect.strref()))
     return emitError() << "invalid dialect namespace '" << dialect << "'";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SparseElementsAttr
 //===----------------------------------------------------------------------===//
 
-/// Return the value of the element at the given index.
-Attribute SparseElementsAttr::getValue(ArrayRef<uint64_t> index) const {
-  assert(isValidIndex(index) && "expected valid multi-dimensional index");
-  auto type = getType();
-
-  // The sparse indices are 64-bit integers, so we can reinterpret the raw data
-  // as a 1-D index array.
-  auto sparseIndices = getIndices();
-  auto sparseIndexValues = sparseIndices.getValues<uint64_t>();
-
-  // Check to see if the indices are a splat.
-  if (sparseIndices.isSplat()) {
-    // If the index is also not a splat of the index value, we know that the
-    // value is zero.
-    auto splatIndex = *sparseIndexValues.begin();
-    if (llvm::any_of(index, [=](uint64_t i) { return i != splatIndex; }))
-      return getZeroAttr();
-
-    // If the indices are a splat, we also expect the values to be a splat.
-    assert(getValues().isSplat() && "expected splat values");
-    return getValues().getSplatValue();
-  }
-
-  // Build a mapping between known indices and the offset of the stored element.
-  llvm::SmallDenseMap<llvm::ArrayRef<uint64_t>, size_t> mappedIndices;
-  auto numSparseIndices = sparseIndices.getType().getDimSize(0);
-  size_t rank = type.getRank();
-  for (size_t i = 0, e = numSparseIndices; i != e; ++i)
-    mappedIndices.try_emplace(
-        {&*std::next(sparseIndexValues.begin(), i * rank), rank}, i);
-
-  // Look for the provided index key within the mapped indices. If the provided
-  // index is not found, then return a zero attribute.
-  auto it = mappedIndices.find(index);
-  if (it == mappedIndices.end())
-    return getZeroAttr();
-
-  // Otherwise, return the held sparse value element.
-  return getValues().getValue(it->second);
-}
-
 /// Get a zero APFloat for the given sparse attribute.
 APFloat SparseElementsAttr::getZeroAPFloat() const {
   auto eltType = getElementType().cast<FloatType>();
   return APFloat(eltType.getFloatSemantics());
 }
 
 /// Get a zero APInt for the given sparse attribute.
 APInt SparseElementsAttr::getZeroAPInt() const {

mlir/lib/Interfaces/InferTypeOpInterface.cpp

 }
 
 int64_t ShapeAdaptor::getDimSize(int index) const {
   assert(hasRank());
   if (auto t = val.dyn_cast<Type>())
     return t.cast<ShapedType>().getDimSize(index);
   if (auto attr = val.dyn_cast<Attribute>())
     return attr.cast<DenseIntElementsAttr>()
-        .getFlatValue<APInt>(index)
+        .getValues<APInt>()[index]
         .getSExtValue();
   auto *stc = val.get<ShapedTypeComponents *>();
   return stc->getDims()[index];
 }
 
 int64_t ShapeAdaptor::getRank() const {
   assert(hasRank());
   if (auto t = val.dyn_cast<Type>())

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp

#include "mlir/Dialect/LLVMIR/LLVMConversions.inc"
   if (auto brOp = dyn_cast<LLVM::BrOp>(opInst)) {
     llvm::BranchInst *branch =
         builder.CreateBr(moduleTranslation.lookupBlock(brOp.getSuccessor()));
     moduleTranslation.mapBranch(&opInst, branch);
     setLoopMetadata(opInst, *branch, builder, moduleTranslation);
     return success();
   }
   if (auto condbrOp = dyn_cast<LLVM::CondBrOp>(opInst)) {
-    auto weights = condbrOp.getBranchWeights();
     llvm::MDNode *branchWeights = nullptr;
-    if (weights) {
+    if (auto weights = condbrOp.getBranchWeights()) {
       // Map weight attributes to LLVM metadata.
-      auto trueWeight =
-          weights.getValue().getValue(0).cast<IntegerAttr>().getInt();
-      auto falseWeight =
-          weights.getValue().getValue(1).cast<IntegerAttr>().getInt();
+      auto weightValues = weights->getValues<APInt>();
+      auto trueWeight = weightValues[0].getSExtValue();
+      auto falseWeight = weightValues[1].getSExtValue();
       branchWeights =
           llvm::MDBuilder(moduleTranslation.getLLVMContext())
               .createBranchWeights(static_cast<uint32_t>(trueWeight),
                                    static_cast<uint32_t>(falseWeight));
     }
     llvm::BranchInst *branch = builder.CreateCondBr(
         moduleTranslation.lookupValue(condbrOp.getOperand(0)),
         moduleTranslation.lookupBlock(condbrOp.getSuccessor(0)),

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

convertDenseElementsAttr(Location loc, DenseElementsAttr denseElementsAttr,
   ArrayRef<int64_t> outerShape = type.getShape();
   if (!hasVectorElementType)
     outerShape = outerShape.drop_back();
 
   // Handle the case of vector splat, LLVM has special support for it.
   if (denseElementsAttr.isSplat() &&
       (type.isa<VectorType>() || hasVectorElementType)) {
     llvm::Constant *splatValue = LLVM::detail::getLLVMConstant(
-        innermostLLVMType, denseElementsAttr.getSplatValue(), loc,
+        innermostLLVMType, denseElementsAttr.getSplatValue<Attribute>(), loc,
         moduleTranslation, /*isTopLevel=*/false);
     llvm::Constant *splatVector =
         llvm::ConstantDataVector::getSplat(0, splatValue);
     SmallVector<llvm::Constant *> constants(numAggregates, splatVector);
     ArrayRef<llvm::Constant *> constantsRef = constants;
     return buildSequentialConstant(constantsRef, outerShape, llvmType, loc);
   }
   if (denseElementsAttr.isSplat())
if (auto splatAttr = attr.dyn_cast<SplatElementsAttr>()) {
     }
     // Splat value is a scalar. Extract it only if the element type is not
     // another sequence type. The recursion terminates because each step removes
     // one outer sequential type.
     bool elementTypeSequential =
         isa<llvm::ArrayType, llvm::VectorType>(elementType);
     llvm::Constant *child = getLLVMConstant(
         elementType,
-        elementTypeSequential ? splatAttr : splatAttr.getSplatValue(), loc,
-        moduleTranslation, false);
+        elementTypeSequential ? splatAttr
+                              : splatAttr.getSplatValue<Attribute>(),
+        loc, moduleTranslation, false);
     if (!child)
       return nullptr;
     if (llvmType->isVectorTy())
       return llvm::ConstantVector::getSplat(
           llvm::ElementCount::get(numElements, /*Scalable=*/false), child);
     if (llvmType->isArrayTy()) {
       auto *arrayType = llvm::ArrayType::get(elementType, numElements);
       SmallVector<llvm::Constant *, 8> constants(numElements, child);

mlir/lib/Target/SPIRV/Serialization/Serializer.cpp

 Serializer::prepareDenseElementsConstant(Location loc, Type constType,
                                          DenseElementsAttr valueAttr, int dim,
                                          MutableArrayRef<uint64_t> index) {
   auto shapedType = valueAttr.getType().dyn_cast<ShapedType>();
   assert(dim <= shapedType.getRank());
   if (shapedType.getRank() == dim) {
     if (auto attr = valueAttr.dyn_cast<DenseIntElementsAttr>()) {
       return attr.getType().getElementType().isInteger(1)
-                 ? prepareConstantBool(loc, attr.getValue<BoolAttr>(index))
-                 : prepareConstantInt(loc, attr.getValue<IntegerAttr>(index));
+                 ? prepareConstantBool(loc, attr.getValues<BoolAttr>()[index])
+                 : prepareConstantInt(loc,
+                                      attr.getValues<IntegerAttr>()[index]);
     }
     if (auto attr = valueAttr.dyn_cast<DenseFPElementsAttr>()) {
-      return prepareConstantFp(loc, attr.getValue<FloatAttr>(index));
+      return prepareConstantFp(loc, attr.getValues<FloatAttr>()[index]);
     }
     return 0;
   }
 
   uint32_t typeID = 0;
   if (failed(processType(loc, constType, typeID))) {
     return 0;
   }

mlir/test/mlir-linalg-ods-gen/test-linalg-ods-yaml-gen.yaml

 
 #       ODS:  "Attribute":$strides
 #       ODS:  $_state.addAttribute("strides", strides);
 
 #       ODS:  bool hasDynamicIndexingMaps();
 #  ODS-NEXT:  LogicalResult verifyIndexingMapRequiredAttributes();
 
 #       IMPL:  getSymbolBindings(Test2Op self)
-#       IMPL:  cst2 = self.strides().getValue<int64_t>({ 0 });
+#       IMPL:  cst2 = self.strides().getValues<int64_t>()[{ 0 }];
 #  IMPL-NEXT:  getAffineConstantExpr(cst2, context)
-#       IMPL:  cst3 = self.strides().getValue<int64_t>({ 1 });
+#       IMPL:  cst3 = self.strides().getValues<int64_t>()[{ 1 }];
 #  IMPL-NEXT:  getAffineConstantExpr(cst3, context)
 
 #       IMPL:  Test2Op::indexing_maps()
 #       IMPL:  = getSymbolBindings(*this);
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d1 * s2, d0 * s3)>"
 #       IMPL:  "affine_map<(d0, d1)[s0, s1, s2, s3] -> (d0, d1)>"
 
 #       IMPL:  Test2Op::getNumRegionArgs() { return 2; }

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

)FMT";
             "  exprs.push_back(getAffineSymbolExpr({0}, context));", i));
       }
 
       // Access an index attribute. Parameters:
       // {0}: Attribute name
       // {1}: Symbol position
       // {2}: Attribute index
       static const char structuredOpAccessAttrFormat[] = R"FMT(
-int64_t cst{1} = self.{0}().getValue<int64_t>({ {2} });
+int64_t cst{1} = self.{0}().getValues<int64_t>()[{ {2} }];
 exprs.push_back(getAffineConstantExpr(cst{1}, context));
 )FMT";
       // Update all symbol bindings mapped to an attribute.
       for (LinalgOperandDef &arg : opConfig.structuredOp->args) {
         if (arg.usage != LinalgOperandDefUsage::attribute)
           continue;
         assert(arg.attributeMap.hasValue());
         for (auto &en :

mlir/unittests/Dialect/Quant/QuantizationUtilsTest.cpp

TEST(QuantizationUtilsTest, convertRankedDenseAttrUniform) {
   // Check Elements attribute shape and kind are not changed.
   auto tensorType = returnedType.cast<TensorType>();
   auto expectedTensorType = realValue.getType().cast<TensorType>();
   EXPECT_EQ(tensorType.getShape(), expectedTensorType.getShape());
   EXPECT_EQ(tensorType.getElementType(), convertedType);
   EXPECT_TRUE(returnedValue.isa<DenseIntElementsAttr>());
 
   // Check Elements attribute element value is expected.
-  auto firstValue = returnedValue.cast<ElementsAttr>().getValue({0, 0});
+  auto firstValue =
+      returnedValue.cast<ElementsAttr>().getValues<Attribute>()[{0, 0}];
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
 TEST(QuantizationUtilsTest, convertRankedSplatAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
   IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
   auto realValue = getTestElementsAttr<DenseElementsAttr, Attribute>(
       &ctx, {1, 2}, getTestFloatAttr(1.0, &ctx));
 
   Type returnedType;
   auto returnedValue =
       quantizeAttrUniform(realValue, quantizedType, converter, returnedType);
 
   // Check Elements attribute shape and kind are not changed.
   auto tensorType = returnedType.cast<TensorType>();
   auto expectedTensorType = realValue.getType().cast<TensorType>();
   EXPECT_EQ(tensorType.getShape(), expectedTensorType.getShape());
   EXPECT_EQ(tensorType.getElementType(), convertedType);
   EXPECT_TRUE(returnedValue.isa<SplatElementsAttr>());
 
   // Check Elements attribute element value is expected.
-  auto firstValue = returnedValue.cast<ElementsAttr>().getValue({0, 0});
+  auto firstValue =
+      returnedValue.cast<ElementsAttr>().getValues<Attribute>()[{0, 0}];
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
 TEST(QuantizationUtilsTest, convertRankedSparseAttrUniform) {
   MLIRContext ctx;
   ctx.getOrLoadDialect<QuantizationDialect>();
   IntegerType convertedType = IntegerType::get(&ctx, 8);
   auto quantizedType = getTestQuantizedType(convertedType, &ctx);
   TestUniformQuantizedValueConverter converter(quantizedType);
   auto realValue = getTestSparseElementsAttr(&ctx, {1, 2});
 
   Type returnedType;
   auto returnedValue =
       quantizeAttrUniform(realValue, quantizedType, converter, returnedType);
 
   // Check Elements attribute shape and kind are not changed.
   auto tensorType = returnedType.cast<TensorType>();
   auto expectedTensorType = realValue.getType().cast<TensorType>();
   EXPECT_EQ(tensorType.getShape(), expectedTensorType.getShape());
   EXPECT_EQ(tensorType.getElementType(), convertedType);
   EXPECT_TRUE(returnedValue.isa<SparseElementsAttr>());
 
   // Check Elements attribute element value is expected.
-  auto firstValue = returnedValue.cast<ElementsAttr>().getValue({0, 0});
+  auto firstValue =
+      returnedValue.cast<ElementsAttr>().getValues<Attribute>()[{0, 0}];
   EXPECT_EQ(firstValue.cast<IntegerAttr>().getInt(), 5);
 }
 
 } // end namespace

mlir/unittests/IR/AttributeTest.cpp

 TEST(DenseScalarTest, ExtractZeroRankElement) {
   MLIRContext context;
   const int elementValue = 12;
   IntegerType intTy = IntegerType::get(&context, 32);
   Attribute value = IntegerAttr::get(intTy, elementValue);
   RankedTensorType shape = RankedTensorType::get({}, intTy);
 
   auto attr = DenseElementsAttr::get(shape, llvm::makeArrayRef({elementValue}));
-  EXPECT_TRUE(attr.getValue({0}) == value);
+  EXPECT_TRUE(attr.getValues<Attribute>()[0] == value);
 }
 
 } // end namespace