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

   1 //===-- AddressRange.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_AddressRange_h_
  11 #define liblldb_AddressRange_h_
  12
  13 #include "lldb/Core/Address.h"
  14
  15 namespace lldb_private {
  16
  17 //----------------------------------------------------------------------
  18 /// @class AddressRange AddressRange.h "lldb/Core/AddressRange.h"
  19 /// @brief A section + offset based address range class.
  20 //----------------------------------------------------------------------
  21 class AddressRange
  22 {
  23 public:
  24     //------------------------------------------------------------------
  25     /// Default constructor.
  26     ///
  27     /// Initialize with a invalid section (NULL), an invalid
  28     /// offset (LLDB_INVALID_ADDRESS), and zero byte size.
  29     //------------------------------------------------------------------
  30     AddressRange ();
  31
  32     //------------------------------------------------------------------
  33     /// Construct with a section pointer, offset, and byte_size.
  34     ///
  35     /// Initialize the address with the supplied \a section, \a
  36     /// offset and \a byte_size.
  37     ///
  38     /// @param[in] section
  39     ///     A section pointer to a valid lldb::Section, or NULL if the
  40     ///     address doesn't have a section or will get resolved later.
  41     ///
  42     /// @param[in] offset
  43     ///     The offset in bytes into \a section.
  44     ///
  45     /// @param[in] byte_size
  46     ///     The size in bytes of the address range.
  47     //------------------------------------------------------------------
  48     AddressRange (const lldb::SectionSP &section, lldb::addr_t offset, lldb::addr_t byte_size);
  49
  50     //------------------------------------------------------------------
  51     /// Construct with a virtual address, section list and byte size.
  52     ///
  53     /// Initialize and resolve the address with the supplied virtual
  54     /// address \a file_addr, and byte size \a byte_size.
  55     ///
  56     /// @param[in] file_addr
  57     ///     A virtual address.
  58     ///
  59     /// @param[in] byte_size
  60     ///     The size in bytes of the address range.
  61     ///
  62     /// @param[in] section_list
  63     ///     A list of sections, one of which may contain the \a vaddr.
  64     //------------------------------------------------------------------
  65     AddressRange (lldb::addr_t file_addr, lldb::addr_t byte_size, const SectionList *section_list = NULL);
  66
  67     //------------------------------------------------------------------
  68     /// Construct with a Address object address and byte size.
  69     ///
  70     /// Initialize by copying the section offset address in \a so_addr,
  71     /// and setting the byte size to \a byte_size.
  72     ///
  73     /// @param[in] so_addr
  74     ///     A section offset address object.
  75     ///
  76     /// @param[in] byte_size
  77     ///     The size in bytes of the address range.
  78     //------------------------------------------------------------------
  79     AddressRange (const Address& so_addr, lldb::addr_t byte_size);
  80
  81     //------------------------------------------------------------------
  82     /// Destructor.
  83     ///
  84     /// The destructor is virtual in case this class is subclassed.
  85     //------------------------------------------------------------------
  86     ~AddressRange ();
  87
  88     //------------------------------------------------------------------
  89     /// Clear the object's state.
  90     ///
  91     /// Sets the section to an invalid value (NULL), an invalid offset
  92     /// (LLDB_INVALID_ADDRESS) and a zero byte size.
  93     //------------------------------------------------------------------
  94     void
  95     Clear ();
  96
  97     //------------------------------------------------------------------
  98     /// Check if a section offset address is contained in this range.
  99     ///
 100     /// @param[in] so_addr
 101     ///     A section offset address object reference.
 102     ///
 103     /// @return
 104     ///     Returns \b true if \a so_addr is contained in this range,
 105     ///     \b false otherwise.
 106     //------------------------------------------------------------------
 107 //    bool
 108 //    Contains (const Address &so_addr) const;
 109
 110     //------------------------------------------------------------------
 111     /// Check if a section offset address is contained in this range.
 112     ///
 113     /// @param[in] so_addr_ptr
 114     ///     A section offset address object pointer.
 115     ///
 116     /// @return
 117     ///     Returns \b true if \a so_addr is contained in this range,
 118     ///     \b false otherwise.
 119     //------------------------------------------------------------------
 120 //    bool
 121 //    Contains (const Address *so_addr_ptr) const;
 122
 123     //------------------------------------------------------------------
 124     /// Check if a section offset \a so_addr when represented as a file
 125     /// address is contained within this object's file address range.
 126     ///
 127     /// @param[in] so_addr
 128     ///     A section offset address object reference.
 129     ///
 130     /// @return
 131     ///     Returns \b true if both \a this and \a so_addr have
 132     ///     resolvable file address values and \a so_addr is contained
 133     ///     in the address range, \b false otherwise.
 134     //------------------------------------------------------------------
 135     bool
 136     ContainsFileAddress (const Address &so_addr) const;
 137
 138     //------------------------------------------------------------------
 139     /// Check if the resolved file address \a file_addr is contained
 140     /// within this object's file address range.
 141     ///
 142     /// @param[in] so_addr
 143     ///     A section offset address object reference.
 144     ///
 145     /// @return
 146     ///     Returns \b true if both \a this has a resolvable file
 147     ///     address value and \a so_addr is contained in the address
 148     ///     range, \b false otherwise.
 149     //------------------------------------------------------------------
 150     bool
 151     ContainsFileAddress (lldb::addr_t file_addr) const;
 152
 153     //------------------------------------------------------------------
 154     /// Check if a section offset \a so_addr when represented as a load
 155     /// address is contained within this object's load address range.
 156     ///
 157     /// @param[in] so_addr
 158     ///     A section offset address object reference.
 159     ///
 160     /// @return
 161     ///     Returns \b true if both \a this and \a so_addr have
 162     ///     resolvable load address values and \a so_addr is contained
 163     ///     in the address range, \b false otherwise.
 164     //------------------------------------------------------------------
 165     bool
 166     ContainsLoadAddress (const Address &so_addr, Target *target) const;
 167
 168     //------------------------------------------------------------------
 169     /// Check if the resolved load address \a load_addr is contained
 170     /// within this object's load address range.
 171     ///
 172     /// @param[in] so_addr
 173     ///     A section offset address object reference.
 174     ///
 175     /// @return
 176     ///     Returns \b true if both \a this has a resolvable load
 177     ///     address value and \a so_addr is contained in the address
 178     ///     range, \b false otherwise.
 179     //------------------------------------------------------------------
 180     bool
 181     ContainsLoadAddress (lldb::addr_t load_addr, Target *target) const;
 182
 183     //------------------------------------------------------------------
 184     /// Dump a description of this object to a Stream.
 185     ///
 186     /// Dump a description of the contents of this object to the
 187     /// supplied stream \a s. There are many ways to display a section
 188     /// offset based address range, and \a style lets the user choose
 189     /// how the base address gets displayed.
 190     ///
 191     /// @param[in] s
 192     ///     The stream to which to dump the object descripton.
 193     ///
 194     /// @param[in] style
 195     ///     The display style for the address.
 196     ///
 197     /// @return
 198     ///     Returns \b true if the address was able to be displayed.
 199     ///     File and load addresses may be unresolved and it may not be
 200     ///     possible to display a valid value, \b false will be returned
 201     ///     in such cases.
 202     ///
 203     /// @see Address::DumpStyle
 204     //------------------------------------------------------------------
 205     bool
 206     Dump (Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style = Address::DumpStyleInvalid) const;
 207
 208     //------------------------------------------------------------------
 209     /// Dump a debug description of this object to a Stream.
 210     ///
 211     /// Dump a debug description of the contents of this object to the
 212     /// supplied stream \a s.
 213     ///
 214     /// The debug description contains verbose internal state such
 215     /// and pointer values, reference counts, etc.
 216     ///
 217     /// @param[in] s
 218     ///     The stream to which to dump the object descripton.
 219     //------------------------------------------------------------------
 220     void
 221     DumpDebug (Stream *s) const;
 222
 223     //------------------------------------------------------------------
 224     /// Get accessor for the base address of the range.
 225     ///
 226     /// @return
 227     ///     A reference to the base address object.
 228     //------------------------------------------------------------------
 229     Address &
 230     GetBaseAddress() { return m_base_addr; }
 231
 232     //------------------------------------------------------------------
 233     /// Get const accessor for the base address of the range.
 234     ///
 235     /// @return
 236     ///     A const reference to the base address object.
 237     //------------------------------------------------------------------
 238     const Address &
 239     GetBaseAddress() const { return m_base_addr; }
 240
 241     //------------------------------------------------------------------
 242     /// Get accessor for the byte size of this range.
 243     ///
 244     /// @return
 245     ///     The size in bytes of this address range.
 246     //------------------------------------------------------------------
 247     lldb::addr_t
 248     GetByteSize () const { return m_byte_size; }
 249
 250     //------------------------------------------------------------------
 251     /// Get the memory cost of this object.
 252     ///
 253     /// @return
 254     ///     The number of bytes that this object occupies in memory.
 255     //------------------------------------------------------------------
 256     size_t
 257     MemorySize () const {
 258         // Noting special for the memory size of a single AddressRange object,
 259         // it is just the size of itself.
 260         return sizeof(AddressRange);
 261     }
 262
 263     //------------------------------------------------------------------
 264     /// Set accessor for the byte size of this range.
 265     ///
 266     /// @param[in] byte_size
 267     ///     The new size in bytes of this address range.
 268     //------------------------------------------------------------------
 269     void
 270     SetByteSize (lldb::addr_t byte_size) { m_byte_size = byte_size; }
 271
 272 protected:
 273     //------------------------------------------------------------------
 274     // Member variables
 275     //------------------------------------------------------------------
 276     Address m_base_addr;    ///< The section offset base address of this range.
 277     lldb::addr_t  m_byte_size;    ///< The size in bytes of this address range.
 278 };
 279
 280 //bool operator== (const AddressRange& lhs, const AddressRange& rhs);
 281
 282 } // namespace lldb_private
 283
 284 #endif  // liblldb_AddressRange_h_