Index: include/llvm/ADT/STLExtras.h
===================================================================
--- include/llvm/ADT/STLExtras.h
+++ include/llvm/ADT/STLExtras.h
@@ -231,34 +231,6 @@
 struct has_rbegin : has_rbegin_impl<typename std::remove_reference<Ty>::type> {
 };
 
-// Returns an iterator_range over the given container which iterates in reverse.
-// Note that the container must have rbegin()/rend() methods for this to work.
-template <typename ContainerTy>
-auto reverse(ContainerTy &&C,
-             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
-                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
-  return make_range(C.rbegin(), C.rend());
-}
-
-// Returns a std::reverse_iterator wrapped around the given iterator.
-template <typename IteratorTy>
-std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
-  return std::reverse_iterator<IteratorTy>(It);
-}
-
-// Returns an iterator_range over the given container which iterates in reverse.
-// Note that the container must have begin()/end() methods which return
-// bidirectional iterators for this to work.
-template <typename ContainerTy>
-auto reverse(
-    ContainerTy &&C,
-    typename std::enable_if<!has_rbegin<ContainerTy>::value>::type * = nullptr)
-    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
-                           llvm::make_reverse_iterator(std::begin(C)))) {
-  return make_range(llvm::make_reverse_iterator(std::end(C)),
-                    llvm::make_reverse_iterator(std::begin(C)));
-}
-
 /// An iterator adaptor that filters the elements of given inner iterators.
 ///
 /// The predicate parameter should be a callable object that accepts the wrapped
@@ -311,8 +283,14 @@
   // have to be engaged.
   filter_iterator(WrappedIteratorT End) : BaseT(End) {}
 
+  // Used to implement a predicate to check if an object is a filter_iterator.
+  template<typename Ty>
+  friend struct is_filter_iterator;
+  struct filter_iterator_tag;
+
 public:
   using BaseT::operator++;
+  using BaseT::wrapped;
 
   filter_iterator &operator++() {
     BaseT::operator++();
@@ -323,8 +301,39 @@
   template <typename RT, typename PT>
   friend iterator_range<filter_iterator<detail::IterOfRange<RT>, PT>>
   make_filter_range(RT &&, PT);
+
+  /// Move the predicate out of the iterator. This invalidates the iterator.
+  PredicateT takePredicate() {
+    assert(Payload && "Cannot find the predicate");
+    PredicateT P = std::move(Payload->Pred);
+    Payload = None;
+    return std::move(P);
+  }
+};
+
+/// Metafunction to determine if T is a filter iterator.
+template <typename Ty> struct is_filter_iterator {
+  using yes = char[1];
+  using no = char[2];
+
+  template <typename Inner>
+  static yes &test(Inner *I, typename Inner::filter_iterator_tag * = nullptr);
+
+  template <typename> static no &test(...);
+
+public:
+  static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
 };
 
+// Returns an iterator_range over the given container which iterates in reverse.
+// Note that the container must have rbegin()/rend() methods for this to work.
+template <typename ContainerTy>
+auto reverse(ContainerTy &&C,
+             typename std::enable_if<has_rbegin<ContainerTy>::value>::type * =
+                 nullptr) -> decltype(make_range(C.rbegin(), C.rend())) {
+  return make_range(C.rbegin(), C.rend());
+}
+
 /// Convenience function that takes a range of elements and a predicate,
 /// and return a new filter_iterator range.
 ///
@@ -343,6 +352,44 @@
                     FilterIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
+// Returns a std::reverse_iterator wrapped around the given iterator.
+template <typename IteratorTy>
+std::reverse_iterator<IteratorTy> make_reverse_iterator(IteratorTy It) {
+  return std::reverse_iterator<IteratorTy>(It);
+}
+
+// Returns an iterator_range over the given container which iterates in reverse.
+// Note that the container must have begin()/end() methods which return
+// bidirectional iterators for this to work.
+template <typename ContainerTy>
+auto reverse(
+    ContainerTy &&C,
+    typename std::enable_if<
+        !has_rbegin<ContainerTy>::value &&
+        !is_filter_iterator<decltype(std::begin(C))>::value>::type * = nullptr)
+    -> decltype(make_range(llvm::make_reverse_iterator(std::end(C)),
+                           llvm::make_reverse_iterator(std::begin(C)))) {
+  return make_range(llvm::make_reverse_iterator(std::end(C)),
+                    llvm::make_reverse_iterator(std::begin(C)));
+}
+
+// Returns an iterator_range over the given filtered range which iterates in
+// reverse. Note that this invalidates the input filtered range.
+template <typename FilteredRangeT>
+auto reverse(
+    FilteredRangeT &&R,
+    typename std::enable_if<is_filter_iterator<decltype(R.begin())>::value,
+                            void>::type * = nullptr)
+    -> decltype(make_filter_range(
+        make_range(llvm::make_reverse_iterator(R.end().wrapped()),
+                   llvm::make_reverse_iterator(R.begin().wrapped())),
+        R.begin().takePredicate())) {
+  return make_filter_range(
+      make_range(llvm::make_reverse_iterator(R.end().wrapped()),
+                 llvm::make_reverse_iterator(R.begin().wrapped())),
+      R.begin().takePredicate());
+}
+
 // forward declarations required by zip_shortest/zip_first
 template <typename R, typename UnaryPredicate>
 bool all_of(R &&range, UnaryPredicate P);
Index: unittests/ADT/IteratorTest.cpp
===================================================================
--- unittests/ADT/IteratorTest.cpp
+++ unittests/ADT/IteratorTest.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/iterator.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "gtest/gtest.h"
@@ -196,6 +197,23 @@
   EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual);
 }
 
+TEST(FilterIteratorTest, ReverseFilterRange) {
+  auto IsOdd = [](int N) { return N % 2 == 1; };
+  int A[] = {0, 1, 2, 3, 4, 5, 6};
+
+  auto Range = reverse(make_filter_range(A, IsOdd));
+  SmallVector<int, 3> Actual(Range.begin(), Range.end());
+  EXPECT_EQ((SmallVector<int, 3>{5, 3, 1}), Actual);
+
+  auto Range2 = reverse(reverse(make_filter_range(A, IsOdd)));
+  SmallVector<int, 3> Actual2(Range2.begin(), Range2.end());
+  EXPECT_EQ((SmallVector<int, 3>{1, 3, 5}), Actual2);
+
+  auto Range3 = reverse(make_filter_range(ArrayRef<int>(), IsOdd));
+  SmallVector<int, 0> Actual3(Range3.begin(), Range3.end());
+  EXPECT_EQ((SmallVector<int, 0>{}), Actual3);
+}
+
 TEST(PointerIterator, Basic) {
   int A[] = {1, 2, 3, 4};
   pointer_iterator<int *> Begin(std::begin(A)), End(std::end(A));