[mlir] Optimize usage of llvm::mapped_iterator

[rriddle]

Summary

mapped_iterator is a useful abstraction for applying a
map function over an existing iterator, but our current
usage ends up allocating storage/making indirect calls
even with the map function is a known function, which
is horribly inefficient. This commit refactors the usage
of mapped_iterator to avoid this, and allows for directly
referencing the map function when dereferencing.

Fixes PR52319

[lattner]

Whoa, thank you for tackling this! The trick with getFunction() is interesting, I hadn't thought about that.

I'm curious: did you consider splitting this into a new static_mapped_iterator class instead of keeping the mapped_iterator design of having a stored function? The static_mapped_iterator could be implemented in roughly the same way, but instead of returning a closure, it could just invoke the "getFunction" member as a static member. This would eliminate the lambdas and the function_ref in ResultElementTypeIterator.

I'm not sure if that makes sense. I'm imagining that clients would look like this:

template <typename UseIteratorT, typename OperandType>
class ValueUserIterator final :  public llvm::static_mapped_iterator<...
public:

  /// Return the map function used by this iterator.
  static Operation *mapElement(OperandType &value) {
      return value.getOwner();
  }

This would reduce pressure on the optimizer (good for -O0 builds in particular) and force a cleaner model.

WDYT?

[rriddle]

In D113511#3119830, @lattner wrote:

Whoa, thank you for tackling this! The trick with getFunction() is interesting, I hadn't thought about that.

I'm curious: did you consider splitting this into a new static_mapped_iterator class instead of keeping the mapped_iterator design of having a stored function? The static_mapped_iterator could be implemented in roughly the same way, but instead of returning a closure, it could just invoke the "getFunction" member as a static member. This would eliminate the lambdas and the function_ref in ResultElementTypeIterator.

Logically in mind I treated mapped_iterator_base as the base for all "map" iterators, and the current "mapped_iterator" is just a specialization of that which uses a stored callable. I opted against using static given that some of the iterators use state in the callable, e.g. the FloatElementIterator uses the float semantics field on the iterator, but maybe static still makes sense given that the callable itself is static?

I'm not sure if that makes sense. I'm imagining that clients would look like this:

template <typename UseIteratorT, typename OperandType>
class ValueUserIterator final :  public llvm::static_mapped_iterator<...
public:

  /// Return the map function used by this iterator.
  static Operation *mapElement(OperandType &value) {
      return value.getOwner();
  }

This would reduce pressure on the optimizer (good for -O0 builds in particular) and force a cleaner model.

WDYT?

Yeah, I considered that but had some downstream users that wanted to interact with the mapping function directly.
I'll try to rewrite those to do something a bit different, let me update this patch.

[rriddle]

resolve comments and add tests

[lattner]

This is great, thank you!

[dblaikie]

llvm/include/llvm/ADT/STLExtras.h

310–312

Could this be implemented in mapped_iterator as an empty optimization if the mapping function happens to be stateless?

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

310–312

I think we can make it work for lambda callable types that capture no state. For non-lambdas I'm not sure though, given that we don't have a reference to the callable, just its type.

[dexonsmith]

llvm/include/llvm/ADT/STLExtras.h

310–312

Maybe this (mapped_iterator_base) could be moved to a base class of mapped_iterator, where the latter adds the getFunction() API, implements mapElement(), and friends mapped_iterator_base to give it access. This would keep the two implementations in sync.

For the EBO, mapped_iterator could delegate getFunction() to a new type mapped_iterator_storage, which avoids storing the function when possible.

315

It'd be nice to avoid requiring ReferenceTy, using the same declval/decltype trick as above.

324

I think this can just be using BaseT = mapped_iterator_base;. Also, is it needed? (see other comment below)

llvm/unittests/ADT/MappedIteratorTest.cpp

54

Seems like this would be more clearly written as:

using BaseT = CustomMapIterator::mapped_iterator_base;

Why expose BaseT?

[rriddle]

llvm/include/llvm/ADT/STLExtras.h

310–312

Let me try to clean this up, thanks.

315

I'm not sure we can here, given that we don't have the exact function type, and I don't think we can resolve DerivedT::mapElement at this point? I could be wrong here.

llvm/unittests/ADT/MappedIteratorTest.cpp

54

This is inheriting the constructor of the base class.

Why expose BaseT?

I've gotten into a habit of using BaseT to avoid the need to have long constructor inheritance lines, though that probably isn't necessary here given that you've pointed out that we don't need the super long template params (thanks for the comment on the other git commit BTW, need to clean other uses of this in MLIR. I wasn't sure if that was allowed on all of the compilers we support).

[dexonsmith]

llvm/include/llvm/ADT/STLExtras.h

315

No, I think you're right.

llvm/unittests/ADT/MappedIteratorTest.cpp

54

This is inheriting the constructor of the base class.

Right, thanks, I misread it as exposing the typedef :).

Why expose BaseT?

I've gotten into a habit of using BaseT to avoid the need to have long constructor inheritance lines, though that probably isn't necessary here given that you've pointed out that we don't need the super long template params (thanks for the comment on the other git commit BTW, need to clean other uses of this in MLIR. I wasn't sure if that was allowed on all of the compilers we support).

Yup, figured that was the reason; I only realized we could do this myself when I saw it in iterator_adaptor_base recently (I was thinking of adding a BaseT...).

I didn't intend to be oblique; wondered if there was some generic algorithm relying on the BaseT typedef and it seemed like this test was ensuring it worked (due to misreading the inherited constructor).

(IMO we should skip these now where possible now that we know we can (the verbose thing is more clear and avoids the extra ad-hoc typedef), but not a big deal if you'd prefer to keep it for some reason.)

[aganea]

mlir/include/mlir/IR/BuiltinAttributes.h

353

Hello! With a recent version of MSVC 2022 (using 17.4.1) I'm seeing a bunch of warnings, such as:

[2055/3926] Building CXX object tools\mlir\lib\IR\CMakeFiles\obj.MLIRIR.dir\BuiltinAttributes.cpp.obj
D:\git\llvm-project\mlir\include\mlir/IR/BuiltinAttributes.h(353): warning C4996: 'std::complex<llvm::APFloat>::complex': warning STL4037: The effect of instantiating the template std::complex for any type other than float, double, or long double is unspecified. You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to suppress this warning.
D:\git\llvm-project\mlir\lib\IR\BuiltinAttributes.cpp(683): warning C4996: 'std::complex<llvm::APInt>::complex': warning STL4037: The effect of instantiating the template std::complex for any type other than float, double, or long double is unspecified. You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to suppress this warning.
D:\git\llvm-project\stage1_msvc_debug\tools\mlir\include\mlir/IR/BuiltinAttributes.h.inc(529): warning C4996: 'std::complex<llvm::APInt>::complex': warning STL4037: The effect of instantiating the template std::complex for any type other than float, double, or long double is unspecified. You can define _SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING to suppress this warning.
D:\git\llvm-project\mlir\include\mlir/IR/BuiltinAttributes.h(985): note: see reference to function template instantiation 'std::complex<llvm::APInt> mlir::SparseElementsAttr::getZeroValue<T>(void) const' being compiled
        with
        [
            T=std::complex<llvm::APInt>
        ]
D:\git\llvm-project\stage1_msvc_debug\tools\mlir\include\mlir/IR/BuiltinAttributeInterfaces.h.inc(310): note: see reference to function template instantiation 'mlir::FailureOr<llvm::mapped_iterator<llvm::detail::SafeIntIterator<__int64,false>,std::function<T (ptrdiff_t)>,_Ret>> mlir::SparseElementsAttr::try_value_begin_impl<T>(mlir::detail::ElementsAttrTrait<ConcreteAttr>::OverloadToken<T>) const' being compiled
        with
        [
            T=std::complex<llvm::APInt>,
            _Ret=std::complex<llvm::APInt>,
            ConcreteAttr=mlir::SparseElementsAttr
        ]

I'm not sure what to do with this. It seems usage of std::complex with anything else than float, double or long double is UB: https://en.cppreference.com/w/cpp/numeric/complex

llvm/include/llvm/ADT/STLExtras.h

inline mapped_iterator<ItTy, FuncTy> map_iterator(ItTy I, FuncTy F) {
   return mapped_iterator<ItTy, FuncTy>(std::move(I), std::move(F));
 }
 
 template <class ContainerTy, class FuncTy>
 auto map_range(ContainerTy &&C, FuncTy F) {
   return make_range(map_iterator(C.begin(), F), map_iterator(C.end(), F));
 }
 
+/// A base type of mapped iterator, that is useful for building derived
+/// iterators that do not need/want to store the map function (as in
+/// mapped_iterator). These iterators must simply provide a `mapElement` method
+/// that defines how to map a value of the iterator to the provided reference
+/// type.
+template <typename DerivedT, typename ItTy, typename ReferenceTy>
+class mapped_iterator_base
+    : public iterator_adaptor_base<
+          DerivedT, ItTy,
+          typename std::iterator_traits<ItTy>::iterator_category,
+          std::remove_reference_t<ReferenceTy>,
+          typename std::iterator_traits<ItTy>::difference_type,
+          std::remove_reference_t<ReferenceTy> *, ReferenceTy> {
+public:
+  using BaseT = mapped_iterator_base<DerivedT, ItTy, ReferenceTy>;
+
+  mapped_iterator_base(ItTy U)
+      : mapped_iterator_base::iterator_adaptor_base(std::move(U)) {}
+
+  ItTy getCurrent() { return this->I; }
+
+  ReferenceTy operator*() const {
+    return static_cast<const DerivedT &>(*this).mapElement(*this->I);
+  }
+};
+
 /// Helper to determine if type T has a member called rbegin().
 template <typename Ty> class has_rbegin_impl {
   using yes = char[1];
   using no = char[2];
 
   template <typename Inner>
   static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
 

llvm/unittests/ADT/MappedIteratorTest.cpp

TEST(MappedIteratorTest, FunctionPreservesReferences) {
   std::map<int, int> M({ {1, 1} });
 
   auto I = map_iterator(V.begin(), [&](int X) -> int& { return M[X]; });
   *I = 42;
 
   EXPECT_EQ(M[1], 42) << "assignment should have modified M";
 }
 
+TEST(MappedIteratorTest, CustomIteratorApplyFunctionOnDereference) {
+  struct CustomMapIterator
+      : public llvm::mapped_iterator_base<CustomMapIterator,
+                                          std::vector<int>::iterator, int> {
+    using BaseT::BaseT;
+
+    /// Map the element to the iterator result type.
+    int mapElement(int X) const { return X + 1; }
+  };
+
+  std::vector<int> V({0});
+
+  CustomMapIterator I(V.begin());
+
+  EXPECT_EQ(*I, 1) << "should have applied function in dereference";
+}
+
+TEST(MappedIteratorTest, CustomIteratorApplyFunctionOnArrow) {
+  struct S {
+    int Z = 0;
+  };
+  struct CustomMapIterator
+      : public llvm::mapped_iterator_base<CustomMapIterator,
+                                          std::vector<int>::iterator, S &> {
+    CustomMapIterator(std::vector<int>::iterator it, S *P) : BaseT(it), P(P) {}
+
+    /// Map the element to the iterator result type.
+    S &mapElement(int X) const { return *(P + X); }
+
+    S *P;
+  };
+
+  std::vector<int> V({0});
+  S Y;
+
+  CustomMapIterator I(V.begin(), &Y);
+
+  I->Z = 42;
+
+  EXPECT_EQ(Y.Z, 42) << "should have applied function during arrow";
+}
+
+TEST(MappedIteratorTest, CustomIteratorFunctionPreservesReferences) {
+  struct CustomMapIterator
+      : public llvm::mapped_iterator_base<CustomMapIterator,
+                                          std::vector<int>::iterator, int &> {
+    CustomMapIterator(std::vector<int>::iterator it, std::map<int, int> &M)
+        : BaseT(it), M(M) {}
+
+    /// Map the element to the iterator result type.
+    int &mapElement(int X) const { return M[X]; }
+
+    std::map<int, int> &M;
+  };
+  std::vector<int> V({1});
+  std::map<int, int> M({{1, 1}});
+
+  auto I = CustomMapIterator(V.begin(), M);
+  *I = 42;
+
+  EXPECT_EQ(M[1], 42) << "assignment should have modified M";
+}
+
 } // anonymous namespace

mlir/include/mlir/IR/BuiltinAttributes.h

private:
     ComplexIntElementIterator(DenseElementsAttr attr, size_t dataIndex);
 
     /// The bitwidth of the element type.
     size_t bitWidth;
   };
 
   /// Iterator for walking over APFloat values.
   class FloatElementIterator final
-      : public llvm::mapped_iterator<IntElementIterator,
-                                     std::function<APFloat(const APInt &)>> {
+      : public llvm::mapped_iterator_base<FloatElementIterator,
+                                          IntElementIterator, APFloat> {
+  public:
+    /// Map the element to the iterator result type.
+    APFloat mapElement(const APInt &value) const {
+      return APFloat(*smt, value);
+    }
+
+  private:
     friend DenseElementsAttr;
 
     /// Initializes the float element iterator to the specified iterator.
-    FloatElementIterator(const llvm::fltSemantics &smt, IntElementIterator it);
+    FloatElementIterator(const llvm::fltSemantics &smt, IntElementIterator it)
+        : BaseT(it), smt(&smt) {}
+
+    /// The float semantics to use when constructing the APFloat.
+    const llvm::fltSemantics *smt;
   };
 
   /// Iterator for walking over complex APFloat values.
   class ComplexFloatElementIterator final
-      : public llvm::mapped_iterator<
+      : public llvm::mapped_iterator_base<ComplexFloatElementIterator,
                                           ComplexIntElementIterator,
-            std::function<std::complex<APFloat>(const std::complex<APInt> &)>> {
+                                          std::complex<APFloat>> {
+  public:
+    /// Map the element to the iterator result type.
+    std::complex<APFloat> mapElement(const std::complex<APInt> &value) const {
+      return {APFloat(*smt, value.real()), APFloat(*smt, value.imag())};
+    }
+
+  private:
     friend DenseElementsAttr;
 
     /// Initializes the float element iterator to the specified iterator.
     ComplexFloatElementIterator(const llvm::fltSemantics &smt,
-                                ComplexIntElementIterator it);
+                                ComplexIntElementIterator it)
+        : BaseT(it), smt(&smt) {}
+
+    /// The float semantics to use when constructing the APFloat.
+    const llvm::fltSemantics *smt;
   };
 
   //===--------------------------------------------------------------------===//
   // Value Querying
   //===--------------------------------------------------------------------===//
 
   /// Returns true if this attribute corresponds to a splat, i.e. if all element
   /// values are the same.
public:
 
   /// 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)>;
+  struct DerivedAttributeElementIterator
+      : public llvm::mapped_iterator_base<DerivedAttributeElementIterator<T>,
+                                          AttributeElementIterator, T> {
+    using DerivedAttributeElementIterator::BaseT::BaseT;
+
+    /// Map the element to the iterator result type.
+    T mapElement(Attribute attr) const { return attr.cast<T>(); }
+  };
   template <typename T, typename = DerivedAttrValueTemplateCheckT<T>>
   iterator_range_impl<DerivedAttributeElementIterator<T>> getValues() const {
-    auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
-    return {Attribute::getType(),
-            llvm::map_range(getValues<Attribute>(),
-                            static_cast<T (*)(Attribute)>(castFn))};
+    using DerivedIterT = DerivedAttributeElementIterator<T>;
+    return {Attribute::getType(), DerivedIterT(value_begin<Attribute>()),
+            DerivedIterT(value_end<Attribute>())};
   }
   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)};
+    return {value_begin<Attribute>()};
   }
   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 {value_end<Attribute>()};
   }
 
   /// 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>>

mlir/include/mlir/IR/Diagnostics.h

 //===----------------------------------------------------------------------===//
 
 /// This class contains all of the information necessary to report a diagnostic
 /// to the DiagnosticEngine. It should generally not be constructed directly,
 /// and instead used transitively via InFlightDiagnostic.
 class Diagnostic {
   using NoteVector = std::vector<std::unique_ptr<Diagnostic>>;
 
-  /// This class implements a wrapper iterator around NoteVector::iterator to
-  /// implicitly dereference the unique_ptr.
-  template <typename IteratorTy, typename NotePtrTy = decltype(*IteratorTy()),
-            typename ResultTy = decltype(**IteratorTy())>
-  class NoteIteratorImpl
-      : public llvm::mapped_iterator<IteratorTy, ResultTy (*)(NotePtrTy)> {
-    static ResultTy &unwrap(NotePtrTy note) { return *note; }
-
-  public:
-    NoteIteratorImpl(IteratorTy it)
-        : llvm::mapped_iterator<IteratorTy, ResultTy (*)(NotePtrTy)>(it,
-                                                                     &unwrap) {}
-  };
-
 public:
   Diagnostic(Location loc, DiagnosticSeverity severity)
       : loc(loc), severity(severity) {}
   Diagnostic(Diagnostic &&) = default;
   Diagnostic &operator=(Diagnostic &&) = default;
 
   /// Returns the severity of this diagnostic.
   DiagnosticSeverity getSeverity() const { return severity; }
public:
   /// Converts the diagnostic to a string.
   std::string str() const;
 
   /// Attaches a note to this diagnostic. A new location may be optionally
   /// provided, if not, then the location defaults to the one specified for this
   /// diagnostic. Notes may not be attached to other notes.
   Diagnostic &attachNote(Optional<Location> noteLoc = llvm::None);
 
-  using note_iterator = NoteIteratorImpl<NoteVector::iterator>;
-  using const_note_iterator = NoteIteratorImpl<NoteVector::const_iterator>;
+  using note_iterator = llvm::pointee_iterator<NoteVector::iterator>;
+  using const_note_iterator =
+      llvm::pointee_iterator<NoteVector::const_iterator>;
 
   /// Returns the notes held by this diagnostic.
   iterator_range<note_iterator> getNotes() {
-    return {notes.begin(), notes.end()};
+    return llvm::make_pointee_range(notes);
   }
   iterator_range<const_note_iterator> getNotes() const {
-    return {notes.begin(), notes.end()};
+    return llvm::make_pointee_range(notes);
   }
 
   /// Allow a diagnostic to be converted to 'failure'.
   operator LogicalResult() const;
 
 private:
   Diagnostic(const Diagnostic &rhs) = delete;
   Diagnostic &operator=(const Diagnostic &rhs) = delete;

mlir/include/mlir/IR/DialectInterface.h

protected:
   const DialectInterface *getInterfaceFor(Dialect *dialect) const {
     auto it = interfaces.find_as(dialect);
     return it == interfaces.end() ? nullptr : *it;
   }
 
   /// An iterator class that iterates the held interface objects of the given
   /// derived interface type.
   template <typename InterfaceT>
-  class iterator : public llvm::mapped_iterator<
+  struct iterator
+      : public llvm::mapped_iterator_base<iterator<InterfaceT>,
                                           InterfaceVectorT::const_iterator,
-                       const InterfaceT &(*)(const DialectInterface *)> {
-    static const InterfaceT &remapIt(const DialectInterface *interface) {
+                                          const InterfaceT &> {
+    using iterator::BaseT::BaseT;
+
+    /// Map the element to the iterator result type.
+    const InterfaceT &mapElement(const DialectInterface *interface) const {
       return *static_cast<const InterfaceT *>(interface);
     }
-
-    iterator(InterfaceVectorT::const_iterator it)
-        : llvm::mapped_iterator<
-              InterfaceVectorT::const_iterator,
-              const InterfaceT &(*)(const DialectInterface *)>(it, &remapIt) {}
-
-    /// Allow access to the constructor.
-    friend DialectInterfaceCollectionBase;
   };
 
   /// Iterator access to the held interfaces.
   template <typename InterfaceT> iterator<InterfaceT> interface_begin() const {
     return iterator<InterfaceT>(orderedInterfaces.begin());
   }
   template <typename InterfaceT> iterator<InterfaceT> interface_end() const {
     return iterator<InterfaceT>(orderedInterfaces.end());

mlir/include/mlir/IR/TypeRange.h

 };
 
 //===----------------------------------------------------------------------===//
 // ValueTypeRange
 
 /// This class implements iteration on the types of a given range of values.
 template <typename ValueIteratorT>
 class ValueTypeIterator final
-    : public llvm::mapped_iterator<ValueIteratorT, Type (*)(Value)> {
-  static Type unwrap(Value value) { return value.getType(); }
-
+    : public llvm::mapped_iterator_base<ValueTypeIterator<ValueIteratorT>,
+                                        ValueIteratorT, Type> {
 public:
-  /// Provide a const dereference method.
-  Type operator*() const { return unwrap(*this->I); }
+  using ValueTypeIterator::BaseT::BaseT;
 
-  /// Initializes the type iterator to the specified value iterator.
-  ValueTypeIterator(ValueIteratorT it)
-      : llvm::mapped_iterator<ValueIteratorT, Type (*)(Value)>(it, &unwrap) {}
+  /// Map the element to the iterator result type.
+  Type mapElement(Value value) const { return value.getType(); }
 };
 
 /// This class implements iteration on the types of a given range of values.
 template <typename ValueRangeT>
 class ValueTypeRange final
     : public llvm::iterator_range<
           ValueTypeIterator<typename ValueRangeT::iterator>> {
 public:

mlir/include/mlir/IR/TypeUtilities.h

 
 /// Returns success if all given types have compatible shapes. That is, they are
 /// all scalars (not shaped), or they are all shaped types and any ranked shapes
 /// have compatible dimensions. The element type does not matter.
 LogicalResult verifyCompatibleShapes(TypeRange types);
 
 /// Dimensions are compatible if all non-dynamic dims are equal.
 LogicalResult verifyCompatibleDims(ArrayRef<int64_t> dims);
+
 //===----------------------------------------------------------------------===//
 // Utility Iterators
 //===----------------------------------------------------------------------===//
 
 // An iterator for the element types of an op's operands of shaped types.
 class OperandElementTypeIterator final
-    : public llvm::mapped_iterator<Operation::operand_iterator,
-                                   Type (*)(Value)> {
+    : public llvm::mapped_iterator_base<OperandElementTypeIterator,
+                                        Operation::operand_iterator, Type> {
 public:
-  /// Initializes the result element type iterator to the specified operand
-  /// iterator.
-  explicit OperandElementTypeIterator(Operation::operand_iterator it);
+  using BaseT::BaseT;
 
-private:
-  static Type unwrap(Value value);
+  /// Map the element to the iterator result type.
+  Type mapElement(Value value) const;
 };
 
 using OperandElementTypeRange = iterator_range<OperandElementTypeIterator>;
 
 // An iterator for the tensor element types of an op's results of shaped types.
 class ResultElementTypeIterator final
-    : public llvm::mapped_iterator<Operation::result_iterator,
-                                   Type (*)(Value)> {
+    : public llvm::mapped_iterator_base<ResultElementTypeIterator,
+                                        Operation::result_iterator, Type> {
 public:
-  /// Initializes the result element type iterator to the specified result
-  /// iterator.
-  explicit ResultElementTypeIterator(Operation::result_iterator it);
+  using BaseT::BaseT;
 
-private:
-  static Type unwrap(Value value);
+  /// Map the element to the iterator result type.
+  Type mapElement(Value value) const;
 };
 
 using ResultElementTypeRange = iterator_range<ResultElementTypeIterator>;
 
 } // end namespace mlir
 
 #endif // MLIR_SUPPORT_TYPEUTILITIES_H

mlir/include/mlir/IR/UseDefLists.h

 //===----------------------------------------------------------------------===//
 // ValueUserIterator
 //===----------------------------------------------------------------------===//
 
 /// An iterator over the users of an IRObject. This is a wrapper iterator around
 /// a specific use iterator.
 template <typename UseIteratorT, typename OperandType>
 class ValueUserIterator final
-    : public llvm::mapped_iterator<UseIteratorT,
-                                   Operation *(*)(OperandType &)> {
-  static Operation *unwrap(OperandType &value) { return value.getOwner(); }
-
+    : public llvm::mapped_iterator_base<
+          ValueUserIterator<UseIteratorT, OperandType>, UseIteratorT,
+          Operation *> {
 public:
-  /// Initializes the user iterator to the specified use iterator.
-  ValueUserIterator(UseIteratorT it)
-      : llvm::mapped_iterator<UseIteratorT, Operation *(*)(OperandType &)>(
-            it, &unwrap) {}
+  using ValueUserIterator::BaseT::BaseT;
+
+  /// Map the element to the iterator result type.
+  Operation *mapElement(OperandType &value) const { return value.getOwner(); }
+
+  /// Provide access to the underlying operation.
   Operation *operator->() { return **this; }
 };
 
 } // namespace mlir
 
 #endif

mlir/lib/IR/BuiltinAttributes.cpp

 DenseElementsAttr::ComplexIntElementIterator::operator*() const {
   size_t storageWidth = getDenseElementStorageWidth(bitWidth);
   size_t offset = getDataIndex() * storageWidth * 2;
   return {readBits(getData(), offset, bitWidth),
           readBits(getData(), offset + storageWidth, bitWidth)};
 }
 
 //===----------------------------------------------------------------------===//
-// FloatElementIterator
-
-DenseElementsAttr::FloatElementIterator::FloatElementIterator(
-    const llvm::fltSemantics &smt, IntElementIterator it)
-    : llvm::mapped_iterator<IntElementIterator,
-                            std::function<APFloat(const APInt &)>>(
-          it, [&](const APInt &val) { return APFloat(smt, val); }) {}
-
-//===----------------------------------------------------------------------===//
-// ComplexFloatElementIterator
-
-DenseElementsAttr::ComplexFloatElementIterator::ComplexFloatElementIterator(
-    const llvm::fltSemantics &smt, ComplexIntElementIterator it)
-    : llvm::mapped_iterator<
-          ComplexIntElementIterator,
-          std::function<std::complex<APFloat>(const std::complex<APInt> &)>>(
-          it, [&](const std::complex<APInt> &val) -> std::complex<APFloat> {
-            return {APFloat(smt, val.real()), APFloat(smt, val.imag())};
-          }) {}
-
-//===----------------------------------------------------------------------===//
 // DenseElementsAttr
 //===----------------------------------------------------------------------===//
 
 /// Method for support type inquiry through isa, cast and dyn_cast.
 bool DenseElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseIntOrFPElementsAttr, DenseStringElementsAttr>();
 }
 

mlir/lib/IR/TypeUtilities.cpp

auto dims = llvm::to_vector<8>(llvm::map_range(
         [&](auto shape) { return shape.getDimSize(i); }));
     if (verifyCompatibleDims(dims).failed())
       return failure();
   }
 
   return success();
 }
 
-OperandElementTypeIterator::OperandElementTypeIterator(
-    Operation::operand_iterator it)
-    : llvm::mapped_iterator<Operation::operand_iterator, Type (*)(Value)>(
-          it, &unwrap) {}
-
-Type OperandElementTypeIterator::unwrap(Value value) {
+Type OperandElementTypeIterator::mapElement(Value value) const {
   return value.getType().cast<ShapedType>().getElementType();
 }
 
-ResultElementTypeIterator::ResultElementTypeIterator(
-    Operation::result_iterator it)
-    : llvm::mapped_iterator<Operation::result_iterator, Type (*)(Value)>(
-          it, &unwrap) {}
-
-Type ResultElementTypeIterator::unwrap(Value value) {
+Type ResultElementTypeIterator::mapElement(Value value) const {
   return value.getType().cast<ShapedType>().getElementType();
 }