Index: llvm/include/llvm/ADT/STLExtras.h
===================================================================
--- llvm/include/llvm/ADT/STLExtras.h
+++ llvm/include/llvm/ADT/STLExtras.h
@@ -283,24 +283,62 @@
 // mapped_iterator - This is a simple iterator adapter that causes a function to
 // be applied whenever operator* is invoked on the iterator.
 
+// Using two different implementations: for functions which return a reference
+// type, and functions which do not
+template <typename ItTy, typename FuncTy,
+          bool FuncReturnTyIsReference = std::is_reference<decltype(
+              std::declval<FuncTy>()(*std::declval<ItTy>()))>::value>
+class mapped_iterator;
+
+// Base class for both implementations
 template <typename ItTy, typename FuncTy,
           typename FuncReturnTy =
-            decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
-class mapped_iterator
+              decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
+class mapped_iterator_base
     : public iterator_adaptor_base<
-             mapped_iterator<ItTy, FuncTy>, ItTy,
-             typename std::iterator_traits<ItTy>::iterator_category,
-             typename std::remove_reference<FuncReturnTy>::type> {
+          mapped_iterator<ItTy, FuncTy>, ItTy,
+          typename std::iterator_traits<ItTy>::iterator_category,
+          typename std::remove_reference<FuncReturnTy>::type> {
 public:
-  mapped_iterator(ItTy U, FuncTy F)
-    : mapped_iterator::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
+  mapped_iterator_base(ItTy U, FuncTy F)
+      : mapped_iterator_base::iterator_adaptor_base(std::move(U)),
+        F(std::move(F)) {}
 
   ItTy getCurrent() { return this->I; }
 
-  FuncReturnTy operator*() const { return F(*this->I); }
+protected:
+  FuncTy F;
+};
+
+// Implementation for reference return type: operator* could simply return the
+// reference
+template <typename ItTy, typename FuncTy>
+class mapped_iterator<ItTy, FuncTy, true>
+    : public mapped_iterator_base<ItTy, FuncTy> {
+public:
+  using mapped_iterator::mapped_iterator_base::mapped_iterator_base;
+
+  typename mapped_iterator::mapped_iterator_base::reference operator*() const {
+    return this->F(*this->I);
+  }
+};
+
+// Implementation for non-reference return type: hold the function's return
+// value in a member variable to make operator* be able to return a reference
+// value
+template <typename ItTy, typename FuncTy>
+class mapped_iterator<ItTy, FuncTy, false>
+    : public mapped_iterator_base<ItTy, FuncTy> {
+public:
+  using mapped_iterator::mapped_iterator_base::mapped_iterator_base;
+
+  typename mapped_iterator::mapped_iterator_base::reference operator*() const {
+    V = this->F(*this->I);
+    return V;
+  }
 
 private:
-  FuncTy F;
+  mutable typename mapped_iterator::mapped_iterator_base::value_type V;
 };
 
 // map_iterator - Provide a convenient way to create mapped_iterators, just like
Index: llvm/unittests/ADT/MappedIteratorTest.cpp
===================================================================
--- llvm/unittests/ADT/MappedIteratorTest.cpp
+++ llvm/unittests/ADT/MappedIteratorTest.cpp
@@ -47,4 +47,17 @@
   EXPECT_EQ(M[1], 42) << "assignment should have modified M";
 }
 
+TEST(MappedIteratorTest, MappedRangeCouldBeReversed) {
+  std::vector<int> V({1, 2, 3});
+
+  auto R1 = map_range(V, [](int N) { return N + 1; }); // {1, 2, 3} -> {2, 3, 4}
+  auto R2 = reverse(R1);                               // {2, 3, 4} -> {4, 3, 2}
+
+  int Val1 = *R1.begin(); // == 2
+  int Val2 = *R2.begin(); // == 4
+
+  EXPECT_EQ(Val1, 2) << "mapped array should start from 2";
+  EXPECT_EQ(Val2, 4) << "reversed array should start from 4";
+}
+
 } // anonymous namespace
Index: llvm/unittests/Analysis/CallGraphTest.cpp
===================================================================
--- llvm/unittests/Analysis/CallGraphTest.cpp
+++ llvm/unittests/Analysis/CallGraphTest.cpp
@@ -23,11 +23,11 @@
   auto X = ++I;
 
   // Should be able to iterate over all nodes of the graph.
-  static_assert(std::is_same<decltype(*I), NodeRef>::value,
+  static_assert(std::is_same<decltype(*I), NodeRef &>::value,
                 "Node type does not match");
-  static_assert(std::is_same<decltype(*X), NodeRef>::value,
+  static_assert(std::is_same<decltype(*X), NodeRef &>::value,
                 "Node type does not match");
-  static_assert(std::is_same<decltype(*E), NodeRef>::value,
+  static_assert(std::is_same<decltype(*E), NodeRef &>::value,
                 "Node type does not match");
 
   NodeRef N = GraphTraits<Ty *>::getEntryNode(G);
@@ -36,9 +36,9 @@
   auto F = GraphTraits<NodeRef>::child_end(N);
 
   // Should be able to iterate over immediate successors of a node.
-  static_assert(std::is_same<decltype(*S), NodeRef>::value,
+  static_assert(std::is_same<decltype(*S), NodeRef &>::value,
                 "Node type does not match");
-  static_assert(std::is_same<decltype(*F), NodeRef>::value,
+  static_assert(std::is_same<decltype(*F), NodeRef &>::value,
                 "Node type does not match");
 }