lldb/include/lldb/Core/AddressRange.h

//===-- 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 lldb::SectionSP &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_