| //===-- AddressRange.h ------------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef liblldb_AddressRange_h_ |
| #define liblldb_AddressRange_h_ |
| |
| #include "lldb/Core/Address.h" |
| #include "lldb/lldb-forward.h" |
| #include "lldb/lldb-types.h" |
| |
| #include <stddef.h> |
| |
| namespace lldb_private { |
| class SectionList; |
| class Stream; |
| class Target; |
| |
| /// \class AddressRange AddressRange.h "lldb/Core/AddressRange.h" |
| /// 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 lldb::SectionSP §ion, 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 = nullptr); |
| |
| /// 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; |
| |
| //------------------------------------------------------------------ |
| /// Extends this range with \b rhs_range if it overlaps this range on the |
| /// right side. The range overlaps on the right side if the base address |
| /// of \b rhs_range lies within this range or if it's contiguous on its |
| /// right side. |
| /// |
| /// @param[in] rhs_range |
| /// The range to extend at the right side. |
| /// |
| /// @return |
| /// Returns \b true if this range was extended, \b false otherwise. |
| //------------------------------------------------------------------ |
| bool Extend(const AddressRange &rhs_range); |
| |
| /// 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 description. |
| /// |
| /// \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 description. |
| 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_ |