contrib/llvm/tools/lldb/include/lldb/Core/VMRange.h

   1 //===-- VMRange.h -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_VMRange_h_
  11 #define liblldb_VMRange_h_
  12
  13 #include "lldb/lldb-private.h"
  14 #include <vector>
  15
  16 namespace lldb_private {
  17
  18 //----------------------------------------------------------------------
  19 // A vm address range. These can represent offsets ranges or actual
  20 // addresses.
  21 //----------------------------------------------------------------------
  22 class VMRange
  23 {
  24 public:
  25
  26     typedef std::vector<VMRange> collection;
  27     typedef collection::iterator iterator;
  28     typedef collection::const_iterator const_iterator;
  29
  30     VMRange() :
  31         m_base_addr(0),
  32         m_byte_size(0)
  33     {
  34     }
  35
  36     VMRange(lldb::addr_t start_addr, lldb::addr_t end_addr) :
  37         m_base_addr(start_addr),
  38         m_byte_size(end_addr > start_addr ? end_addr - start_addr : 0)
  39     {
  40     }
  41
  42     ~VMRange()
  43     {
  44     }
  45
  46     void
  47     Clear ()
  48     {
  49         m_base_addr = 0;
  50         m_byte_size = 0;
  51     }
  52
  53     // Set the start and end values
  54     void
  55     Reset (lldb::addr_t start_addr, lldb::addr_t end_addr)
  56     {
  57         SetBaseAddress (start_addr);
  58         SetEndAddress (end_addr);
  59     }
  60
  61     // Set the start value for the range, and keep the same size
  62     void
  63     SetBaseAddress (lldb::addr_t base_addr)
  64     {
  65         m_base_addr = base_addr;
  66     }
  67
  68     void
  69     SetEndAddress (lldb::addr_t end_addr)
  70     {
  71         const lldb::addr_t base_addr = GetBaseAddress();
  72         if (end_addr > base_addr)
  73             m_byte_size = end_addr - base_addr;
  74         else
  75             m_byte_size = 0;
  76     }
  77
  78     lldb::addr_t
  79     GetByteSize () const
  80     {
  81         return m_byte_size;
  82     }
  83
  84     void
  85     SetByteSize (lldb::addr_t byte_size)
  86     {
  87         m_byte_size = byte_size;
  88     }
  89
  90     lldb::addr_t
  91     GetBaseAddress () const
  92     {
  93         return m_base_addr;
  94     }
  95
  96     lldb::addr_t
  97     GetEndAddress () const
  98     {
  99         return GetBaseAddress() + m_byte_size;
 100     }
 101
 102     bool
 103     IsValid() const
 104     {
 105         return m_byte_size > 0;
 106     }
 107
 108     bool
 109     Contains (lldb::addr_t addr) const
 110     {
 111         return (GetBaseAddress() <= addr) && (addr < GetEndAddress());
 112     }
 113
 114     bool
 115     Contains (const VMRange& range) const
 116     {
 117         if (Contains(range.GetBaseAddress()))
 118         {
 119             lldb::addr_t range_end = range.GetEndAddress();
 120             return (GetBaseAddress() <= range_end) && (range_end <= GetEndAddress());
 121         }
 122         return false;
 123     }
 124
 125     void
 126     Dump (Stream *s, lldb::addr_t base_addr = 0, uint32_t addr_width = 8) const;
 127
 128     class ValueInRangeUnaryPredicate
 129     {
 130     public:
 131         ValueInRangeUnaryPredicate(lldb::addr_t value) :
 132             _value(value)
 133         {
 134         }
 135         bool operator()(const VMRange& range) const
 136         {
 137             return range.Contains(_value);
 138         }
 139         lldb::addr_t _value;
 140     };
 141
 142     class RangeInRangeUnaryPredicate
 143     {
 144     public:
 145         RangeInRangeUnaryPredicate(VMRange range) :
 146             _range(range)
 147         {
 148         }
 149         bool operator()(const VMRange& range) const
 150         {
 151             return range.Contains(_range);
 152         }
 153         const VMRange& _range;
 154     };
 155
 156     static bool
 157     ContainsValue(const VMRange::collection& coll, lldb::addr_t value);
 158
 159     static bool
 160     ContainsRange(const VMRange::collection& coll, const VMRange& range);
 161
 162     // Returns a valid index into coll when a match is found, else UINT32_MAX
 163     // is returned
 164     static size_t
 165     FindRangeIndexThatContainsValue (const VMRange::collection& coll, lldb::addr_t value);
 166
 167 protected:
 168     lldb::addr_t m_base_addr;
 169     lldb::addr_t m_byte_size;
 170 };
 171
 172 bool operator== (const VMRange& lhs, const VMRange& rhs);
 173 bool operator!= (const VMRange& lhs, const VMRange& rhs);
 174 bool operator<  (const VMRange& lhs, const VMRange& rhs);
 175 bool operator<= (const VMRange& lhs, const VMRange& rhs);
 176 bool operator>  (const VMRange& lhs, const VMRange& rhs);
 177 bool operator>= (const VMRange& lhs, const VMRange& rhs);
 178
 179 } // namespace lldb_private
 180
 181 #endif  // liblldb_VMRange_h_