//===-- AddressRange.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_AddressRange_h_ #define liblldb_AddressRange_h_ #include "lldb/Core/Address.h" namespace lldb_private { //---------------------------------------------------------------------- /// @class AddressRange AddressRange.h "lldb/Core/AddressRange.h" /// @brief A section + offset based address range class. //---------------------------------------------------------------------- class AddressRange { public: //------------------------------------------------------------------ /// Default constructor. /// /// Initialize with a invalid section (NULL), an invalid /// offset (LLDB_INVALID_ADDRESS), and zero byte size. //------------------------------------------------------------------ AddressRange (); //------------------------------------------------------------------ /// Construct with a section pointer, offset, and byte_size. /// /// Initialize the address with the supplied \a section, \a /// offset and \a byte_size. /// /// @param[in] section /// A section pointer to a valid lldb::Section, or NULL if the /// address doesn't have a section or will get resolved later. /// /// @param[in] offset /// The offset in bytes into \a section. /// /// @param[in] byte_size /// The size in bytes of the address range. //------------------------------------------------------------------ AddressRange (const Section* section, lldb::addr_t offset, lldb::addr_t byte_size); //------------------------------------------------------------------ /// Construct with a virtual address, section list and byte size. /// /// Initialize and resolve the address with the supplied virtual /// address \a file_addr, and byte size \a byte_size. /// /// @param[in] file_addr /// A virtual address. /// /// @param[in] byte_size /// The size in bytes of the address range. /// /// @param[in] section_list /// A list of sections, one of which may contain the \a vaddr. //------------------------------------------------------------------ AddressRange (lldb::addr_t file_addr, lldb::addr_t byte_size, const SectionList *section_list = NULL); //------------------------------------------------------------------ /// Construct with a Address object address and byte size. /// /// Initialize by copying the section offset address in \a so_addr, /// and setting the byte size to \a byte_size. /// /// @param[in] so_addr /// A section offset address object. /// /// @param[in] byte_size /// The size in bytes of the address range. //------------------------------------------------------------------ AddressRange (const Address& so_addr, lldb::addr_t byte_size); //------------------------------------------------------------------ /// Destructor. /// /// The destructor is virtual in case this class is subclassed. //------------------------------------------------------------------ ~AddressRange (); //------------------------------------------------------------------ /// Clear the object's state. /// /// Sets the section to an invalid value (NULL), an invalid offset /// (LLDB_INVALID_ADDRESS) and a zero byte size. //------------------------------------------------------------------ void Clear (); //------------------------------------------------------------------ /// Check if a section offset address is contained in this range. /// /// @param[in] so_addr /// A section offset address object reference. /// /// @return /// Returns \b true if \a so_addr is contained in this range, /// \b false otherwise. //------------------------------------------------------------------ // bool // Contains (const Address &so_addr) const; //------------------------------------------------------------------ /// Check if a section offset address is contained in this range. /// /// @param[in] so_addr_ptr /// A section offset address object pointer. /// /// @return /// Returns \b true if \a so_addr is contained in this range, /// \b false otherwise. //------------------------------------------------------------------ // bool // Contains (const Address *so_addr_ptr) const; //------------------------------------------------------------------ /// Check if a section offset \a so_addr when represented as a file /// address is contained within this object's file address range. /// /// @param[in] so_addr /// A section offset address object reference. /// /// @return /// Returns \b true if both \a this and \a so_addr have /// resolvable file address values and \a so_addr is contained /// in the address range, \b false otherwise. //------------------------------------------------------------------ bool ContainsFileAddress (const Address &so_addr) const; //------------------------------------------------------------------ /// Check if the resolved file address \a file_addr is contained /// within this object's file address range. /// /// @param[in] so_addr /// A section offset address object reference. /// /// @return /// Returns \b true if both \a this has a resolvable file /// address value and \a so_addr is contained in the address /// range, \b false otherwise. //------------------------------------------------------------------ bool ContainsFileAddress (lldb::addr_t file_addr) const; //------------------------------------------------------------------ /// Check if a section offset \a so_addr when represented as a load /// address is contained within this object's load address range. /// /// @param[in] so_addr /// A section offset address object reference. /// /// @return /// Returns \b true if both \a this and \a so_addr have /// resolvable load address values and \a so_addr is contained /// in the address range, \b false otherwise. //------------------------------------------------------------------ bool ContainsLoadAddress (const Address &so_addr, Target *target) const; //------------------------------------------------------------------ /// Check if the resolved load address \a load_addr is contained /// within this object's load address range. /// /// @param[in] so_addr /// A section offset address object reference. /// /// @return /// Returns \b true if both \a this has a resolvable load /// address value and \a so_addr is contained in the address /// range, \b false otherwise. //------------------------------------------------------------------ bool ContainsLoadAddress (lldb::addr_t load_addr, Target *target) const; //------------------------------------------------------------------ /// Dump a description of this object to a Stream. /// /// Dump a description of the contents of this object to the /// supplied stream \a s. There are many ways to display a section /// offset based address range, and \a style lets the user choose /// how the base address gets displayed. /// /// @param[in] s /// The stream to which to dump the object descripton. /// /// @param[in] style /// The display style for the address. /// /// @return /// Returns \b true if the address was able to be displayed. /// File and load addresses may be unresolved and it may not be /// possible to display a valid value, \b false will be returned /// in such cases. /// /// @see Address::DumpStyle //------------------------------------------------------------------ bool Dump (Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style = Address::DumpStyleInvalid) const; //------------------------------------------------------------------ /// Dump a debug description of this object to a Stream. /// /// Dump a debug description of the contents of this object to the /// supplied stream \a s. /// /// The debug description contains verbose internal state such /// and pointer values, reference counts, etc. /// /// @param[in] s /// The stream to which to dump the object descripton. //------------------------------------------------------------------ void DumpDebug (Stream *s) const; //------------------------------------------------------------------ /// Get accessor for the base address of the range. /// /// @return /// A reference to the base address object. //------------------------------------------------------------------ Address & GetBaseAddress() { return m_base_addr; } //------------------------------------------------------------------ /// Get const accessor for the base address of the range. /// /// @return /// A const reference to the base address object. //------------------------------------------------------------------ const Address & GetBaseAddress() const { return m_base_addr; } //------------------------------------------------------------------ /// Get accessor for the byte size of this range. /// /// @return /// The size in bytes of this address range. //------------------------------------------------------------------ lldb::addr_t GetByteSize () const { return m_byte_size; } //------------------------------------------------------------------ /// Get the memory cost of this object. /// /// @return /// The number of bytes that this object occupies in memory. //------------------------------------------------------------------ size_t MemorySize () const { // Noting special for the memory size of a single AddressRange object, // it is just the size of itself. return sizeof(AddressRange); } //------------------------------------------------------------------ /// Set accessor for the byte size of this range. /// /// @param[in] byte_size /// The new size in bytes of this address range. //------------------------------------------------------------------ void SetByteSize (lldb::addr_t byte_size) { m_byte_size = byte_size; } protected: //------------------------------------------------------------------ // Member variables //------------------------------------------------------------------ Address m_base_addr; ///< The section offset base address of this range. lldb::addr_t m_byte_size; ///< The size in bytes of this address range. }; //bool operator== (const AddressRange& lhs, const AddressRange& rhs); } // namespace lldb_private #endif // liblldb_AddressRange_h_