aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Core/AddressRange.h
blob: 9d781f3e85ae9bce3d724fb4c8819df9ab2e5e32 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
//===-- 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 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_