Index: include/llvm/ADT/ArrayRef.h
===================================================================
--- include/llvm/ADT/ArrayRef.h
+++ include/llvm/ADT/ArrayRef.h
@@ -12,6 +12,7 @@
 
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include <array>
 #include <vector>
@@ -165,12 +166,6 @@
       return std::equal(begin(), end(), RHS.begin());
     }
 
-    /// slice(n) - Chop off the first N elements of the array.
-    ArrayRef<T> slice(size_t N) const {
-      assert(N <= size() && "Invalid specifier");
-      return ArrayRef<T>(data()+N, size()-N);
-    }
-
     /// slice(n, m) - Chop off the first N elements of the array, and keep M
     /// elements in the array.
     ArrayRef<T> slice(size_t N, size_t M) const {
@@ -178,6 +173,9 @@
       return ArrayRef<T>(data()+N, M);
     }
 
+    /// slice(n) - Chop off the first N elements of the array.
+    ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
+
     /// \brief Drop the first \p N elements of the array.
     ArrayRef<T> drop_front(size_t N = 1) const {
       assert(size() >= N && "Dropping more elements than exist");
@@ -190,6 +188,18 @@
       return slice(0, size() - N);
     }
 
+    /// \brief Return a copy of *this with the first N elements satisfying the
+    /// given predicate removed.
+    template <class Pred> ArrayRef<T> drop_while(const Pred &P) const {
+      return ArrayRef<T>(find_if_not(*this, P), end());
+    }
+
+    /// \brief Return a copy of *this with the first N elements not satisfying
+    /// the given predicate removed.
+    template <class Pred> ArrayRef<T> drop_until(const Pred &P) const {
+      return ArrayRef<T>(find_if(*this, P), end());
+    }
+
     /// \brief Return a copy of *this with only the first \p N elements.
     ArrayRef<T> take_front(size_t N = 1) const {
       if (N >= size())
@@ -204,6 +214,18 @@
       return drop_front(size() - N);
     }
 
+    /// \brief Return the first N elements of this Array that satisfy the given
+    /// predicate.
+    template <class Pred> ArrayRef<T> take_while(const Pred &P) const {
+      return ArrayRef<T>(begin(), find_if_not(*this, P));
+    }
+
+    /// \brief Return the first N elements of this Array that don't satisfy the
+    /// given predicate.
+    template <class Pred> ArrayRef<T> take_until(const Pred &P) const {
+      return ArrayRef<T>(begin(), find_if(*this, P));
+    }
+
     /// @}
     /// @name Operator Overloads
     /// @{
@@ -317,17 +339,16 @@
       return data()[this->size()-1];
     }
 
-    /// slice(n) - Chop off the first N elements of the array.
-    MutableArrayRef<T> slice(size_t N) const {
-      assert(N <= this->size() && "Invalid specifier");
-      return MutableArrayRef<T>(data()+N, this->size()-N);
-    }
-
     /// slice(n, m) - Chop off the first N elements of the array, and keep M
     /// elements in the array.
     MutableArrayRef<T> slice(size_t N, size_t M) const {
-      assert(N+M <= this->size() && "Invalid specifier");
-      return MutableArrayRef<T>(data()+N, M);
+      assert(N + M <= this->size() && "Invalid specifier");
+      return MutableArrayRef<T>(this->data() + N, M);
+    }
+
+    /// slice(n) - Chop off the first N elements of the array.
+    MutableArrayRef<T> slice(size_t N) const {
+      return slice(N, this->size() - N);
     }
 
     /// \brief Drop the first \p N elements of the array.
@@ -341,6 +362,18 @@
       return slice(0, this->size() - N);
     }
 
+    /// \brief Return a copy of *this with the first N elements satisfying the
+    /// given predicate removed.
+    template <class Pred> MutableArrayRef<T> drop_while(const Pred &P) const {
+      return MutableArrayRef<T>(find_if_not(*this, P), end());
+    }
+
+    /// \brief Return a copy of *this with the first N elements not satisfying
+    /// the given predicate removed.
+    template <class Pred> MutableArrayRef<T> drop_until(const Pred &P) const {
+      return MutableArrayRef<T>(find_if(*this, P), end());
+    }
+
     /// \brief Return a copy of *this with only the first \p N elements.
     MutableArrayRef<T> take_front(size_t N = 1) const {
       if (N >= this->size())
@@ -355,6 +388,18 @@
       return drop_front(this->size() - N);
     }
 
+    /// \brief Return the first N elements of this Array that satisfy the given
+    /// predicate.
+    template <class Pred> MutableArrayRef<T> take_while(const Pred &P) const {
+      return MutableArrayRef<T>(begin(), find_if_not(*this, F));
+    }
+
+    /// \brief Return the first N elements of this Array that don't satisfy the
+    /// given predicate.
+    template <class Pred> MutableArrayRef<T> take_until(const Pred &P) const {
+      return MutableArrayRef<T>(begin(), find_if(*this, F));
+    }
+
     /// @}
     /// @name Operator Overloads
     /// @{
Index: include/llvm/ADT/STLExtras.h
===================================================================
--- include/llvm/ADT/STLExtras.h
+++ include/llvm/ADT/STLExtras.h
@@ -622,6 +622,11 @@
   return std::find_if(Range.begin(), Range.end(), Pred);
 }
 
+template <typename R, class T>
+auto find_if_not(R &&Range, const T &Pred) -> decltype(Range.begin()) {
+  return std::find_if_not(Range.begin(), Range.end(), Pred);
+}
+
 /// Provide wrappers to std::remove_if which take ranges instead of having to
 /// pass begin/end explicitly.
 template<typename R, class UnaryPredicate>
Index: unittests/ADT/ArrayRefTest.cpp
===================================================================
--- unittests/ADT/ArrayRefTest.cpp
+++ unittests/ADT/ArrayRefTest.cpp
@@ -102,6 +102,28 @@
   EXPECT_EQ(1U, AR3.drop_front(AR3.size() - 1).size());
 }
 
+TEST(ArrayRefTest, DropWhile) {
+  static const int TheNumbers[] = {1, 3, 5, 8, 10, 11};
+  ArrayRef<int> AR1(TheNumbers);
+  ArrayRef<int> Expected = AR1.drop_front(3);
+  EXPECT_EQ(Expected, AR1.drop_while([](const int &N) { return N % 2 == 1; }));
+
+  EXPECT_EQ(AR1, AR1.drop_while([](const int &N) { return N < 0; }));
+  EXPECT_EQ(ArrayRef<int>(),
+            AR1.drop_while([](const int &N) { return N > 0; }));
+}
+
+TEST(ArrayRefTest, DropUntil) {
+  static const int TheNumbers[] = {1, 3, 5, 8, 10, 11};
+  ArrayRef<int> AR1(TheNumbers);
+  ArrayRef<int> Expected = AR1.drop_front(3);
+  EXPECT_EQ(Expected, AR1.drop_until([](const int &N) { return N % 2 == 0; }));
+
+  EXPECT_EQ(ArrayRef<int>(),
+            AR1.drop_until([](const int &N) { return N < 0; }));
+  EXPECT_EQ(AR1, AR1.drop_until([](const int &N) { return N > 0; }));
+}
+
 TEST(ArrayRefTest, TakeBack) {
   static const int TheNumbers[] = {4, 8, 15, 16, 23, 42};
   ArrayRef<int> AR1(TheNumbers);
@@ -116,6 +138,28 @@
   EXPECT_TRUE(AR1.take_front(2).equals(AR2));
 }
 
+TEST(ArrayRefTest, TakeWhile) {
+  static const int TheNumbers[] = {1, 3, 5, 8, 10, 11};
+  ArrayRef<int> AR1(TheNumbers);
+  ArrayRef<int> Expected = AR1.take_front(3);
+  EXPECT_EQ(Expected, AR1.take_while([](const int &N) { return N % 2 == 1; }));
+
+  EXPECT_EQ(ArrayRef<int>(),
+            AR1.take_while([](const int &N) { return N < 0; }));
+  EXPECT_EQ(AR1, AR1.take_while([](const int &N) { return N > 0; }));
+}
+
+TEST(ArrayRefTest, TakeUntil) {
+  static const int TheNumbers[] = {1, 3, 5, 8, 10, 11};
+  ArrayRef<int> AR1(TheNumbers);
+  ArrayRef<int> Expected = AR1.take_front(3);
+  EXPECT_EQ(Expected, AR1.take_until([](const int &N) { return N % 2 == 0; }));
+
+  EXPECT_EQ(AR1, AR1.take_until([](const int &N) { return N < 0; }));
+  EXPECT_EQ(ArrayRef<int>(),
+            AR1.take_until([](const int &N) { return N > 0; }));
+}
+
 TEST(ArrayRefTest, Equals) {
   static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8};
   ArrayRef<int> AR1(A1);