LLDB  mainline
AddressRange.h
Go to the documentation of this file.
1 //===-- AddressRange.h ------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_CORE_ADDRESSRANGE_H
10 #define LLDB_CORE_ADDRESSRANGE_H
11 
12 #include "lldb/Core/Address.h"
13 #include "lldb/lldb-forward.h"
14 #include "lldb/lldb-types.h"
15 
16 #include <cstddef>
17 
18 namespace lldb_private {
19 class SectionList;
20 class Stream;
21 class Target;
22 
23 /// \class AddressRange AddressRange.h "lldb/Core/AddressRange.h"
24 /// A section + offset based address range class.
25 class AddressRange {
26 public:
27  /// Default constructor.
28  ///
29  /// Initialize with a invalid section (NULL), an invalid offset
30  /// (LLDB_INVALID_ADDRESS), and zero byte size.
31  AddressRange();
32 
33  /// Construct with a section pointer, offset, and byte_size.
34  ///
35  /// Initialize the address with the supplied \a section, \a offset and \a
36  /// 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  AddressRange(const lldb::SectionSP &section, lldb::addr_t offset,
48  lldb::addr_t byte_size);
49 
50  /// Construct with a virtual address, section list and byte size.
51  ///
52  /// Initialize and resolve the address with the supplied virtual address \a
53  /// file_addr, and byte size \a byte_size.
54  ///
55  /// \param[in] file_addr
56  /// A virtual address.
57  ///
58  /// \param[in] byte_size
59  /// The size in bytes of the address range.
60  ///
61  /// \param[in] section_list
62  /// A list of sections, one of which may contain the \a vaddr.
63  AddressRange(lldb::addr_t file_addr, lldb::addr_t byte_size,
64  const SectionList *section_list = nullptr);
65 
66  /// Construct with a Address object address and byte size.
67  ///
68  /// Initialize by copying the section offset address in \a so_addr, and
69  /// setting the byte size to \a byte_size.
70  ///
71  /// \param[in] so_addr
72  /// A section offset address object.
73  ///
74  /// \param[in] byte_size
75  /// The size in bytes of the address range.
76  AddressRange(const Address &so_addr, lldb::addr_t byte_size);
77 
78  /// Destructor.
79  ///
80  /// The destructor is virtual in case this class is subclassed.
81  ~AddressRange();
82 
83  /// Clear the object's state.
84  ///
85  /// Sets the section to an invalid value (NULL), an invalid offset
86  /// (LLDB_INVALID_ADDRESS) and a zero byte size.
87  void Clear();
88 
89  /// Check if a section offset address is contained in this range.
90  ///
91  /// \param[in] so_addr
92  /// A section offset address object reference.
93  ///
94  /// \return
95  /// Returns \b true if \a so_addr is contained in this range,
96  /// \b false otherwise.
97  bool Contains(const Address &so_addr) const;
98 
99  /// Check if a section offset address is contained in this range.
100  ///
101  /// \param[in] so_addr_ptr
102  /// A section offset address object pointer.
103  ///
104  /// \return
105  /// Returns \b true if \a so_addr is contained in this range,
106  /// \b false otherwise.
107  // bool
108  // Contains (const Address *so_addr_ptr) const;
109 
110  /// Check if a section offset \a so_addr when represented as a file address
111  /// is contained within this object's file address range.
112  ///
113  /// \param[in] so_addr
114  /// A section offset address object reference.
115  ///
116  /// \return
117  /// Returns \b true if both \a this and \a so_addr have
118  /// resolvable file address values and \a so_addr is contained
119  /// in the address range, \b false otherwise.
120  bool ContainsFileAddress(const Address &so_addr) const;
121 
122  /// Check if the resolved file address \a file_addr is contained within this
123  /// object's file address range.
124  ///
125  /// \param[in] file_addr
126  /// A section offset address object reference.
127  ///
128  /// \return
129  /// Returns \b true if both \a this has a resolvable file
130  /// address value and \a so_addr is contained in the address
131  /// range, \b false otherwise.
132  bool ContainsFileAddress(lldb::addr_t file_addr) const;
133 
134  /// Check if a section offset \a so_addr when represented as a load address
135  /// is contained within this object's load address range.
136  ///
137  /// \param[in] so_addr
138  /// A section offset address object reference.
139  ///
140  /// \return
141  /// Returns \b true if both \a this and \a so_addr have
142  /// resolvable load address values and \a so_addr is contained
143  /// in the address range, \b false otherwise.
144  bool ContainsLoadAddress(const Address &so_addr, Target *target) const;
145 
146  /// Check if the resolved load address \a load_addr is contained within this
147  /// object's load address range.
148  ///
149  /// \return
150  /// Returns \b true if both \a this has a resolvable load
151  /// address value and \a so_addr is contained in the address
152  /// range, \b false otherwise.
153  bool ContainsLoadAddress(lldb::addr_t load_addr, Target *target) const;
154 
155  //------------------------------------------------------------------
156  /// Extends this range with \b rhs_range if it overlaps this range on the
157  /// right side. The range overlaps on the right side if the base address
158  /// of \b rhs_range lies within this range or if it's contiguous on its
159  /// right side.
160  ///
161  /// @param[in] rhs_range
162  /// The range to extend at the right side.
163  ///
164  /// @return
165  /// Returns \b true if this range was extended, \b false otherwise.
166  //------------------------------------------------------------------
167  bool Extend(const AddressRange &rhs_range);
168 
169  /// Dump a description of this object to a Stream.
170  ///
171  /// Dump a description of the contents of this object to the supplied stream
172  /// \a s. There are many ways to display a section offset based address
173  /// range, and \a style lets the user choose how the base address gets
174  /// displayed.
175  ///
176  /// \param[in] s
177  /// The stream to which to dump the object description.
178  ///
179  /// \param[in] style
180  /// The display style for the address.
181  ///
182  /// \return
183  /// Returns \b true if the address was able to be displayed.
184  /// File and load addresses may be unresolved and it may not be
185  /// possible to display a valid value, \b false will be returned
186  /// in such cases.
187  ///
188  /// \see Address::DumpStyle
189  bool
190  Dump(Stream *s, Target *target, Address::DumpStyle style,
191  Address::DumpStyle fallback_style = Address::DumpStyleInvalid) const;
192 
193  /// Dump a debug description of this object to a Stream.
194  ///
195  /// Dump a debug description of the contents of this object to the supplied
196  /// stream \a s.
197  ///
198  /// The debug description contains verbose internal state such and pointer
199  /// values, reference counts, etc.
200  ///
201  /// \param[in] s
202  /// The stream to which to dump the object description.
203  void DumpDebug(Stream *s) const;
204 
205  /// Get accessor for the base address of the range.
206  ///
207  /// \return
208  /// A reference to the base address object.
210 
211  /// Get const accessor for the base address of the range.
212  ///
213  /// \return
214  /// A const reference to the base address object.
215  const Address &GetBaseAddress() const { return m_base_addr; }
216 
217  /// Get accessor for the byte size of this range.
218  ///
219  /// \return
220  /// The size in bytes of this address range.
222 
223  /// Get the memory cost of this object.
224  ///
225  /// \return
226  /// The number of bytes that this object occupies in memory.
227  size_t MemorySize() const {
228  // Noting special for the memory size of a single AddressRange object, it
229  // is just the size of itself.
230  return sizeof(AddressRange);
231  }
232 
233  /// Set accessor for the byte size of this range.
234  ///
235  /// \param[in] byte_size
236  /// The new size in bytes of this address range.
237  void SetByteSize(lldb::addr_t byte_size) { m_byte_size = byte_size; }
238 
239 protected:
240  // Member variables
241  Address m_base_addr; ///< The section offset base address of this range.
242  lldb::addr_t m_byte_size = 0; ///< The size in bytes of this address range.
243 };
244 
245 // bool operator== (const AddressRange& lhs, const AddressRange& rhs);
246 
247 } // namespace lldb_private
248 
249 #endif // LLDB_CORE_ADDRESSRANGE_H
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::AddressRange::m_base_addr
Address m_base_addr
The section offset base address of this range.
Definition: AddressRange.h:241
lldb_private::AddressRange::GetByteSize
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
lldb_private::SectionList
Definition: Section.h:34
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Target
Definition: Target.h:454
lldb_private::AddressRange::m_byte_size
lldb::addr_t m_byte_size
The size in bytes of this address range.
Definition: AddressRange.h:242
lldb_private::AddressRange
Definition: AddressRange.h:25
Address.h
lldb_private::AddressRange::ContainsFileAddress
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
Definition: AddressRange.cpp:71
lldb-types.h
lldb_private::AddressRange::DumpDebug
void DumpDebug(Stream *s) const
Dump a debug description of this object to a Stream.
Definition: AddressRange.cpp:208
lldb_private::AddressRange::Extend
bool Extend(const AddressRange &rhs_range)
Extends this range with rhs_range if it overlaps this range on the right side.
Definition: AddressRange.cpp:134
lldb_private::Address::DumpStyleInvalid
@ DumpStyleInvalid
Invalid dump style.
Definition: Address.h:65
lldb_private::AddressRange::Clear
void Clear()
Clear the object's state.
Definition: AddressRange.cpp:152
lldb_private::AddressRange::AddressRange
AddressRange()
Default constructor.
Definition: AddressRange.cpp:31
lldb_private::AddressRange::Dump
bool Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style=Address::DumpStyleInvalid) const
Dump a description of this object to a Stream.
Definition: AddressRange.cpp:157
lldb_private::Address
Definition: Address.h:59
lldb_private::AddressRange::SetByteSize
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:237
lldb-forward.h
lldb_private::AddressRange::~AddressRange
~AddressRange()
Destructor.
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Address::DumpStyle
DumpStyle
Dump styles allow the Address::Dump(Stream *,DumpStyle) const function to display Address contents in...
Definition: Address.h:63
lldb_private::AddressRange::GetBaseAddress
const Address & GetBaseAddress() const
Get const accessor for the base address of the range.
Definition: AddressRange.h:215
lldb_private::AddressRange::Contains
bool Contains(const Address &so_addr) const
Check if a section offset address is contained in this range.
Definition: AddressRange.cpp:46
lldb_private::AddressRange::ContainsLoadAddress
bool ContainsLoadAddress(const Address &so_addr, Target *target) const
Check if a section offset so_addr when represented as a load address is contained within this object'...
Definition: AddressRange.cpp:102
lldb_private::AddressRange::MemorySize
size_t MemorySize() const
Get the memory cost of this object.
Definition: AddressRange.h:227