Index: include/llvm/ADT/STLExtras.h
===================================================================
--- include/llvm/ADT/STLExtras.h
+++ include/llvm/ADT/STLExtras.h
@@ -508,9 +508,11 @@
                     EarlyIncIteratorT(std::end(std::forward<RangeT>(Range))));
 }
 
-// forward declarations required by zip_shortest/zip_first
+// forward declarations required by zip_shortest/zip_first/zip_longest
 template <typename R, typename UnaryPredicate>
 bool all_of(R &&range, UnaryPredicate P);
+template <typename R, typename UnaryPredicate>
+bool any_of(R &&range, UnaryPredicate P);
 
 template <size_t... I> struct index_sequence;
 
@@ -661,6 +663,243 @@
       std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
 }
 
+namespace detail {
+template <typename Iter>
+static Iter next_or_end(const Iter &I, const Iter &End) {
+  if (I == End)
+    return End;
+  return std::next(I);
+}
+
+template <typename Iter>
+static auto deref_or_none(const Iter &I, const Iter &End)
+    -> llvm::Optional<typename std::remove_const<
+        typename std::remove_reference<decltype(*I)>::type>::type> {
+  if (I == End)
+    return None;
+  return *I;
+}
+
+template <typename... Iters> struct ZipLongestOptionalValueType {
+  using type = std::tuple<
+      llvm::Optional<typename std::remove_const<typename std::remove_reference<
+          decltype(*std::declval<Iters>())>::type>::type>...>;
+};
+
+template <typename... Iters>
+class zip_longest_optional_iterator
+    : public iterator_facade_base<
+          zip_longest_optional_iterator<Iters...>,
+          typename std::common_type<
+              std::forward_iterator_tag,
+              typename std::iterator_traits<Iters>::iterator_category...>::type,
+          typename ZipLongestOptionalValueType<Iters...>::type,
+          typename std::iterator_traits<typename std::tuple_element<
+              0, std::tuple<Iters...>>::type>::difference_type,
+          typename ZipLongestOptionalValueType<Iters...>::type *,
+          typename ZipLongestOptionalValueType<Iters...>::type> {
+public:
+  using value_type = typename ZipLongestOptionalValueType<Iters...>::type;
+
+private:
+  std::tuple<Iters...> iterators;
+  std::tuple<Iters...> end_iterators;
+
+  template <size_t... Ns>
+  bool test(const zip_longest_optional_iterator<Iters...> &other,
+            index_sequence<Ns...>) const {
+    return llvm::any_of(
+        std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
+                                    std::get<Ns>(other.iterators)...},
+        identity<bool>{});
+  }
+
+  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
+    return value_type(
+        deref_or_none(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
+  }
+
+  template <size_t... Ns>
+  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
+    return std::tuple<Iters...>(
+        next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
+  }
+
+public:
+  zip_longest_optional_iterator(std::pair<Iters &&, Iters &&>... ts)
+      : iterators(std::forward<Iters>(ts.first)...),
+        end_iterators(std::forward<Iters>(ts.second)...) {}
+
+  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
+
+  value_type operator*() const { return deref(index_sequence_for<Iters...>{}); }
+
+  zip_longest_optional_iterator<Iters...> &operator++() {
+    iterators = tup_inc(index_sequence_for<Iters...>{});
+    return *this;
+  }
+
+  bool operator==(const zip_longest_optional_iterator<Iters...> &other) const {
+    return !test(other, index_sequence_for<Iters...>{});
+  }
+};
+
+template <typename... Args> class zip_longest_optional_range {
+public:
+  using iterator = zip_longest_optional_iterator<decltype(
+      std::begin(std::declval<Args>()))...>;
+  using iterator_category = typename iterator::iterator_category;
+  using value_type = typename iterator::value_type;
+  using difference_type = typename iterator::difference_type;
+  using pointer = typename iterator::pointer;
+  using reference = typename iterator::reference;
+
+private:
+  std::tuple<Args...> ts;
+
+  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
+    return iterator(std::make_pair(std::begin(std::get<Ns>(ts)),
+                                   std::end(std::get<Ns>(ts)))...);
+  }
+
+  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
+    return iterator(std::make_pair(std::end(std::get<Ns>(ts)),
+                                   std::end(std::get<Ns>(ts)))...);
+  }
+
+public:
+  zip_longest_optional_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
+
+  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
+  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
+};
+} // namespace detail
+
+/// Iterate over two or more iterators at the same time. Iteration continues
+/// until all iterators reach the end. The llvm::Optional only contains a value
+/// if the iterator has not reached the end.
+template <typename T, typename U, typename... Args>
+detail::zip_longest_optional_range<T, U, Args...>
+zip_longest_optional(T &&t, U &&u, Args &&... args) {
+  return detail::zip_longest_optional_range<T, U, Args...>(
+      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
+}
+
+namespace detail {
+template <typename Iter>
+static auto deref_or_default(const Iter &I, const Iter &End) ->
+    typename std::remove_const<
+        typename std::remove_reference<decltype(*I)>::type>::type {
+  if (I == End)
+    return {}; // value-initialize
+  return *I;
+}
+
+template <typename... Iters> struct ZipLongestDefaultValueType {
+  using type =
+      std::tuple<typename std::remove_const<typename std::remove_reference<
+          decltype(*std::declval<Iters>())>::type>::type...>;
+};
+
+template <typename... Iters>
+class zip_longest_default_iterator
+    : public iterator_facade_base<
+          zip_longest_default_iterator<Iters...>,
+          typename std::common_type<
+              std::forward_iterator_tag,
+              typename std::iterator_traits<Iters>::iterator_category...>::type,
+          typename ZipLongestDefaultValueType<Iters...>::type,
+          typename std::iterator_traits<typename std::tuple_element<
+              0, std::tuple<Iters...>>::type>::difference_type,
+          typename ZipLongestDefaultValueType<Iters...>::type *,
+          typename ZipLongestDefaultValueType<Iters...>::type> {
+public:
+  using value_type = typename ZipLongestDefaultValueType<Iters...>::type;
+
+private:
+  std::tuple<Iters...> iterators;
+  std::tuple<Iters...> end_iterators;
+
+  template <size_t... Ns>
+  bool test(const zip_longest_default_iterator<Iters...> &other,
+            index_sequence<Ns...>) const {
+    return llvm::any_of(
+        std::initializer_list<bool>{std::get<Ns>(this->iterators) !=
+                                    std::get<Ns>(other.iterators)...},
+        identity<bool>{});
+  }
+
+  template <size_t... Ns> value_type deref(index_sequence<Ns...>) const {
+    return value_type(deref_or_default(std::get<Ns>(iterators),
+                                       std::get<Ns>(end_iterators))...);
+  }
+
+  template <size_t... Ns>
+  decltype(iterators) tup_inc(index_sequence<Ns...>) const {
+    return std::tuple<Iters...>(
+        next_or_end(std::get<Ns>(iterators), std::get<Ns>(end_iterators))...);
+  }
+
+public:
+  zip_longest_default_iterator(std::pair<Iters &&, Iters &&>... ts)
+      : iterators(std::forward<Iters>(ts.first)...),
+        end_iterators(std::forward<Iters>(ts.second)...) {}
+
+  value_type operator*() { return deref(index_sequence_for<Iters...>{}); }
+
+  value_type operator*() const { return deref(index_sequence_for<Iters...>{}); }
+
+  zip_longest_default_iterator<Iters...> &operator++() {
+    iterators = tup_inc(index_sequence_for<Iters...>{});
+    return *this;
+  }
+
+  bool operator==(const zip_longest_default_iterator<Iters...> &other) const {
+    return !test(other, index_sequence_for<Iters...>{});
+  }
+};
+
+template <typename... Args> class zip_longest_default_range {
+public:
+  using iterator = zip_longest_default_iterator<decltype(
+      std::begin(std::declval<Args>()))...>;
+  using iterator_category = typename iterator::iterator_category;
+  using value_type = typename iterator::value_type;
+  using difference_type = typename iterator::difference_type;
+  using pointer = typename iterator::pointer;
+  using reference = typename iterator::reference;
+
+private:
+  std::tuple<Args...> ts;
+
+  template <size_t... Ns> iterator begin_impl(index_sequence<Ns...>) const {
+    return iterator(std::make_pair(std::begin(std::get<Ns>(ts)),
+                                   std::end(std::get<Ns>(ts)))...);
+  }
+
+  template <size_t... Ns> iterator end_impl(index_sequence<Ns...>) const {
+    return iterator(std::make_pair(std::end(std::get<Ns>(ts)),
+                                   std::end(std::get<Ns>(ts)))...);
+  }
+
+public:
+  zip_longest_default_range(Args &&... ts_) : ts(std::forward<Args>(ts_)...) {}
+
+  iterator begin() const { return begin_impl(index_sequence_for<Args...>{}); }
+  iterator end() const { return end_impl(index_sequence_for<Args...>{}); }
+};
+} // namespace detail
+
+/// Iterate over two or more iterators at the same time. Iteration continues
+/// until all iterators reach the end. The type's value-initialized default is
+/// used for iterators that have reached the end when others did not.
+template <typename T, typename U, typename... Args>
+detail::zip_longest_default_range<T, U, Args...>
+zip_longest_default(T &&t, U &&u, Args &&... args) {
+  return detail::zip_longest_default_range<T, U, Args...>(
+      std::forward<T>(t), std::forward<U>(u), std::forward<Args>(args)...);
+}
+
 /// Iterator wrapper that concatenates sequences together.
 ///
 /// This can concatenate different iterators, even with different types, into
Index: unittests/ADT/IteratorTest.cpp
===================================================================
--- unittests/ADT/IteratorTest.cpp
+++ unittests/ADT/IteratorTest.cpp
@@ -328,6 +328,84 @@
   EXPECT_EQ(iters, 4u);
 }
 
+TEST(ZipIteratorTest, ZipLongestOptionalBasic) {
+  using namespace std;
+  const SmallVector<unsigned, 6> pi{3, 1, 4, 1, 5, 9};
+  const SmallVector<bool, 8> lsb{1, 1, 0, 1, 1, 1, 0, 0};
+
+  {
+    int total_iters = 0;
+    int left_iters = 0;
+    int right_iters = 0;
+    for (auto tup : zip_longest_optional(pi, lsb)) {
+      total_iters += 1;
+      if (get<0>(tup).hasValue())
+        left_iters += 1;
+      if (get<1>(tup).hasValue())
+        right_iters += 1;
+      if (!get<0>(tup) || !get<1>(tup))
+        continue;
+      EXPECT_EQ(get<0>(tup).getValue() & 0x01, get<1>(tup).getValue());
+    }
+    EXPECT_EQ(total_iters, 8);
+    EXPECT_EQ(left_iters, 6);
+    EXPECT_EQ(right_iters, 8);
+  }
+
+  {
+    int total_iters = 0;
+    int left_iters = 0;
+    int right_iters = 0;
+    for (auto tup : zip_longest_optional(lsb, pi)) {
+      total_iters += 1;
+      if (get<0>(tup).hasValue())
+        left_iters += 1;
+      if (get<1>(tup).hasValue())
+        right_iters += 1;
+      if (!get<0>(tup) || !get<1>(tup))
+        continue;
+      EXPECT_EQ(get<0>(tup).getValue(), get<1>(tup).getValue() & 0x01);
+    }
+    EXPECT_EQ(total_iters, 8);
+    EXPECT_EQ(left_iters, 8);
+    EXPECT_EQ(right_iters, 6);
+  }
+}
+
+TEST(ZipIteratorTest, ZipLongestDefaultBasic) {
+  using namespace std;
+  const SmallVector<unsigned, 6> pi{3, 1, 4, 1, 5, 9};
+  const SmallVector<const unsigned *, 4> ptr{&pi[0], &pi[1], &pi[2], &pi[3]};
+
+  {
+    int total_iters = 0;
+    int nondefault_iters = 0;
+    for (auto tup : zip_longest_default(pi, ptr)) {
+      total_iters += 1;
+      if (!get<1>(tup))
+        continue;
+      nondefault_iters += 1;
+      EXPECT_EQ(get<0>(tup), *get<1>(tup));
+    }
+    EXPECT_EQ(total_iters, 6);
+    EXPECT_EQ(nondefault_iters, 4);
+  }
+
+  {
+    int total_iters = 0;
+    int nondefault_iters = 0;
+    for (auto tup : zip_longest_default(ptr, pi)) {
+      total_iters += 1;
+      if (!get<0>(tup))
+        continue;
+      nondefault_iters += 1;
+      EXPECT_EQ(*get<0>(tup), get<1>(tup));
+    }
+    EXPECT_EQ(total_iters, 6);
+    EXPECT_EQ(nondefault_iters, 4);
+  }
+}
+
 TEST(ZipIteratorTest, Mutability) {
   using namespace std;
   const SmallVector<unsigned, 4> pi{3, 1, 4, 1, 5, 9};
@@ -382,6 +460,40 @@
   EXPECT_TRUE(all_of(pi, [](unsigned n) { return (n & 0x01) == 0; }));
 }
 
+TEST(ZipIteratorTest, ZipLongestOptionalFilter) {
+  using namespace std;
+  vector<unsigned> pi{3, 1, 4, 1, 5, 9};
+
+  int iters = 0;
+  auto zipped = zip_longest_optional(pi, vector<bool>{1, 1, 0, 1});
+  for (auto tup : make_filter_range(zipped, [](decltype(zipped)::value_type t) {
+         return !get<1>(t).hasValue() || get<1>(t).getValue();
+       })) {
+    iters += 1;
+    if (!get<0>(tup).hasValue() || !get<1>(tup).hasValue())
+      continue;
+    EXPECT_EQ(get<0>(tup).getValue() & 0x01, get<1>(tup).getValue());
+  }
+
+  // Should have skipped pi[2].
+  EXPECT_EQ(iters, 5);
+}
+
+TEST(ZipIteratorTest, ZipLongestDefaultFilter) {
+  using namespace std;
+  vector<unsigned> pi{3, 1, 4, 1, 5, 9};
+
+  int iters = 0;
+  auto zipped = zip_longest_default(pi, vector<bool>{0, 0, 1, 0});
+  for (auto tup : make_filter_range(
+           zipped, [](decltype(zipped)::value_type t) { return !get<1>(t); })) {
+    iters += 1;
+    EXPECT_EQ(~get<0>(tup) & 0x01, get<1>(tup));
+  }
+
+  EXPECT_EQ(iters, 5);
+}
+
 TEST(ZipIteratorTest, Reverse) {
   using namespace std;
   vector<unsigned> ascending{0, 1, 2, 3, 4, 5};