Index: vendor/lldb/dist-release_70/include/lldb/Utility/VMRange.h
===================================================================
--- vendor/lldb/dist-release_70/include/lldb/Utility/VMRange.h	(revision 337640)
+++ vendor/lldb/dist-release_70/include/lldb/Utility/VMRange.h	(revision 337641)
@@ -1,128 +1,110 @@
 //===-- VMRange.h -----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_VMRange_h_
 #define liblldb_VMRange_h_
 
 #include "lldb/lldb-types.h" // for addr_t
 
 #include <stddef.h> // for size_t
 #include <stdint.h> // for uint32_t
 #include <vector>
 
 namespace lldb_private {
 class Stream;
 }
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // A vm address range. These can represent offsets ranges or actual
 // addresses.
 //----------------------------------------------------------------------
 class VMRange {
 public:
   typedef std::vector<VMRange> collection;
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   VMRange() : m_base_addr(0), m_byte_size(0) {}
 
   VMRange(lldb::addr_t start_addr, lldb::addr_t end_addr)
       : m_base_addr(start_addr),
         m_byte_size(end_addr > start_addr ? end_addr - start_addr : 0) {}
 
   ~VMRange() {}
 
   void Clear() {
     m_base_addr = 0;
     m_byte_size = 0;
   }
 
   // Set the start and end values
   void Reset(lldb::addr_t start_addr, lldb::addr_t end_addr) {
     SetBaseAddress(start_addr);
     SetEndAddress(end_addr);
   }
 
   // Set the start value for the range, and keep the same size
   void SetBaseAddress(lldb::addr_t base_addr) { m_base_addr = base_addr; }
 
   void SetEndAddress(lldb::addr_t end_addr) {
     const lldb::addr_t base_addr = GetBaseAddress();
     if (end_addr > base_addr)
       m_byte_size = end_addr - base_addr;
     else
       m_byte_size = 0;
   }
 
   lldb::addr_t GetByteSize() const { return m_byte_size; }
 
   void SetByteSize(lldb::addr_t byte_size) { m_byte_size = byte_size; }
 
   lldb::addr_t GetBaseAddress() const { return m_base_addr; }
 
   lldb::addr_t GetEndAddress() const { return GetBaseAddress() + m_byte_size; }
 
   bool IsValid() const { return m_byte_size > 0; }
 
   bool Contains(lldb::addr_t addr) const {
     return (GetBaseAddress() <= addr) && (addr < GetEndAddress());
   }
 
   bool Contains(const VMRange &range) const {
     if (Contains(range.GetBaseAddress())) {
       lldb::addr_t range_end = range.GetEndAddress();
       return (GetBaseAddress() <= range_end) && (range_end <= GetEndAddress());
     }
     return false;
   }
 
   void Dump(Stream *s, lldb::addr_t base_addr = 0,
             uint32_t addr_width = 8) const;
 
-  class ValueInRangeUnaryPredicate {
-  public:
-    ValueInRangeUnaryPredicate(lldb::addr_t value) : _value(value) {}
-    bool operator()(const VMRange &range) const {
-      return range.Contains(_value);
-    }
-    lldb::addr_t _value;
-  };
-
-  class RangeInRangeUnaryPredicate {
-  public:
-    RangeInRangeUnaryPredicate(VMRange range) : _range(range) {}
-    bool operator()(const VMRange &range) const {
-      return range.Contains(_range);
-    }
-    const VMRange &_range;
-  };
-
   static bool ContainsValue(const VMRange::collection &coll,
                             lldb::addr_t value);
 
   static bool ContainsRange(const VMRange::collection &coll,
                             const VMRange &range);
 
 protected:
   lldb::addr_t m_base_addr;
   lldb::addr_t m_byte_size;
 };
 
 bool operator==(const VMRange &lhs, const VMRange &rhs);
 bool operator!=(const VMRange &lhs, const VMRange &rhs);
 bool operator<(const VMRange &lhs, const VMRange &rhs);
 bool operator<=(const VMRange &lhs, const VMRange &rhs);
 bool operator>(const VMRange &lhs, const VMRange &rhs);
 bool operator>=(const VMRange &lhs, const VMRange &rhs);
 
 } // namespace lldb_private
 
 #endif // liblldb_VMRange_h_
Index: vendor/lldb/dist-release_70/source/Utility/VMRange.cpp
===================================================================
--- vendor/lldb/dist-release_70/source/Utility/VMRange.cpp	(revision 337640)
+++ vendor/lldb/dist-release_70/source/Utility/VMRange.cpp	(revision 337641)
@@ -1,69 +1,71 @@
 //===-- VMRange.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/VMRange.h"
 
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-types.h" // for addr_t
 
 #include <algorithm>
 #include <iterator> // for distance
 #include <vector>   // for const_iterator
 
 #include <stddef.h> // for size_t
 #include <stdint.h> // for UINT32_MAX, uint32_t
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool VMRange::ContainsValue(const VMRange::collection &coll,
                             lldb::addr_t value) {
-  ValueInRangeUnaryPredicate in_range_predicate(value);
-  return llvm::find_if(coll, in_range_predicate) != coll.end();
+  return llvm::find_if(coll, [&](const VMRange &r) {
+           return r.Contains(value);
+         }) != coll.end();
 }
 
 bool VMRange::ContainsRange(const VMRange::collection &coll,
                             const VMRange &range) {
-  RangeInRangeUnaryPredicate in_range_predicate(range);
-  return llvm::find_if(coll, in_range_predicate) != coll.end();
+  return llvm::find_if(coll, [&](const VMRange &r) {
+           return r.Contains(range);
+         }) != coll.end();
 }
 
 void VMRange::Dump(Stream *s, lldb::addr_t offset, uint32_t addr_width) const {
   s->AddressRange(offset + GetBaseAddress(), offset + GetEndAddress(),
                   addr_width);
 }
 
 bool lldb_private::operator==(const VMRange &lhs, const VMRange &rhs) {
   return lhs.GetBaseAddress() == rhs.GetBaseAddress() &&
          lhs.GetEndAddress() == rhs.GetEndAddress();
 }
 
 bool lldb_private::operator!=(const VMRange &lhs, const VMRange &rhs) {
   return !(lhs == rhs);
 }
 
 bool lldb_private::operator<(const VMRange &lhs, const VMRange &rhs) {
   if (lhs.GetBaseAddress() < rhs.GetBaseAddress())
     return true;
   else if (lhs.GetBaseAddress() > rhs.GetBaseAddress())
     return false;
   return lhs.GetEndAddress() < rhs.GetEndAddress();
 }
 
 bool lldb_private::operator<=(const VMRange &lhs, const VMRange &rhs) {
   return !(lhs > rhs);
 }
 
 bool lldb_private::operator>(const VMRange &lhs, const VMRange &rhs) {
   return rhs < lhs;
 }
 
 bool lldb_private::operator>=(const VMRange &lhs, const VMRange &rhs) {
   return !(lhs < rhs);
 }