LLDB mainline
AddressRange.cpp
Go to the documentation of this file.
1//===-- AddressRange.cpp --------------------------------------------------===//
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
10#include "lldb/Core/Module.h"
11#include "lldb/Core/Section.h"
12#include "lldb/Target/Target.h"
15#include "lldb/Utility/Stream.h"
16#include "lldb/lldb-defines.h"
17#include "lldb/lldb-types.h"
18
19#include "llvm/Support/Compiler.h"
20
21#include <memory>
22
23#include <cinttypes>
24
25namespace lldb_private {
26class SectionList;
27}
28
29using namespace lldb;
30using namespace lldb_private;
31
32AddressRange::AddressRange() : m_base_addr() {}
33
35 const SectionList *section_list)
36 : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
37
39 addr_t byte_size)
40 : m_base_addr(section, offset), m_byte_size(byte_size) {}
41
42AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
43 : m_base_addr(so_addr), m_byte_size(byte_size) {}
44
46
47bool AddressRange::Contains(const Address &addr) const {
48 SectionSP range_sect_sp = GetBaseAddress().GetSection();
49 SectionSP addr_sect_sp = addr.GetSection();
50 if (range_sect_sp) {
51 if (!addr_sect_sp ||
52 range_sect_sp->GetModule() != addr_sect_sp->GetModule())
53 return false; // Modules do not match.
54 } else if (addr_sect_sp) {
55 return false; // Range has no module but "addr" does because addr has a
56 // section
57 }
58 // Either the modules match, or both have no module, so it is ok to compare
59 // the file addresses in this case only.
60 return ContainsFileAddress(addr);
61}
62
64 if (addr.GetSection() == m_base_addr.GetSection())
65 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
66 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
67 if (file_base_addr == LLDB_INVALID_ADDRESS)
68 return false;
69
70 addr_t file_addr = addr.GetFileAddress();
71 if (file_addr == LLDB_INVALID_ADDRESS)
72 return false;
73
74 if (file_base_addr <= file_addr)
75 return (file_addr - file_base_addr) < GetByteSize();
76
77 return false;
78}
79
81 if (file_addr == LLDB_INVALID_ADDRESS)
82 return false;
83
84 addr_t file_base_addr = GetBaseAddress().GetFileAddress();
85 if (file_base_addr == LLDB_INVALID_ADDRESS)
86 return false;
87
88 if (file_base_addr <= file_addr)
89 return (file_addr - file_base_addr) < GetByteSize();
90
91 return false;
92}
93
95 Target *target) const {
96 if (addr.GetSection() == m_base_addr.GetSection())
97 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
98 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
99 if (load_base_addr == LLDB_INVALID_ADDRESS)
100 return false;
101
102 addr_t load_addr = addr.GetLoadAddress(target);
103 if (load_addr == LLDB_INVALID_ADDRESS)
104 return false;
105
106 if (load_base_addr <= load_addr)
107 return (load_addr - load_base_addr) < GetByteSize();
108
109 return false;
110}
111
112bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const {
113 if (load_addr == LLDB_INVALID_ADDRESS)
114 return false;
115
116 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
117 if (load_base_addr == LLDB_INVALID_ADDRESS)
118 return false;
119
120 if (load_base_addr <= load_addr)
121 return (load_addr - load_base_addr) < GetByteSize();
122
123 return false;
124}
125
126bool AddressRange::Extend(const AddressRange &rhs_range) {
127 addr_t lhs_end_addr = GetBaseAddress().GetFileAddress() + GetByteSize();
128 addr_t rhs_base_addr = rhs_range.GetBaseAddress().GetFileAddress();
129
130 if (!ContainsFileAddress(rhs_range.GetBaseAddress()) &&
131 lhs_end_addr != rhs_base_addr)
132 // The ranges don't intersect at all on the right side of this range.
133 return false;
134
135 addr_t rhs_end_addr = rhs_base_addr + rhs_range.GetByteSize();
136 if (lhs_end_addr >= rhs_end_addr)
137 // The rhs range totally overlaps this one, nothing to add.
138 return false;
139
140 m_byte_size += rhs_end_addr - lhs_end_addr;
141 return true;
142}
143
146 m_byte_size = 0;
147}
148
150 return m_base_addr.IsValid() && (m_byte_size > 0);
151}
152
154 Address::DumpStyle fallback_style) const {
156 int addr_size = sizeof(addr_t);
157 if (target)
158 addr_size = target->GetArchitecture().GetAddressByteSize();
159
160 bool show_module = false;
161 switch (style) {
162 default:
163 break;
166 s->PutChar('[');
167 m_base_addr.Dump(s, target, style, fallback_style);
168 s->PutChar('-');
170 addr_size);
171 s->PutChar(')');
172 return true;
173 break;
174
176 show_module = true;
177 [[fallthrough]];
179 vmaddr = m_base_addr.GetFileAddress();
180 break;
181
183 vmaddr = m_base_addr.GetLoadAddress(target);
184 break;
185 }
186
187 if (vmaddr != LLDB_INVALID_ADDRESS) {
188 if (show_module) {
189 ModuleSP module_sp(GetBaseAddress().GetModule());
190 if (module_sp)
191 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
192 "<Unknown>"));
193 }
194 DumpAddressRange(s->AsRawOstream(), vmaddr, vmaddr + GetByteSize(),
195 addr_size);
196 return true;
197 } else if (fallback_style != Address::DumpStyleInvalid) {
198 return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
199 }
200
201 return false;
202}
203
205 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64
206 ", byte_size = 0x%16.16" PRIx64 "\n",
207 static_cast<const void *>(this),
208 static_cast<void *>(m_base_addr.GetSection().get()),
210}
211
213 addr_t start_addr = m_base_addr.GetLoadAddress(target);
214 if (start_addr != LLDB_INVALID_ADDRESS) {
215 // We have a valid target and the address was resolved, or we have a base
216 // address with no section. Just print out a raw address range: [<addr>,
217 // <addr>)
218 s->Printf("[0x%" PRIx64 "-0x%" PRIx64 ")", start_addr,
219 start_addr + GetByteSize());
220 return true;
221 }
222
223 // Either no target or the address wasn't resolved, print as
224 // <module>[<file-addr>-<file-addr>)
225 const char *file_name = "";
226 const auto section_sp = m_base_addr.GetSection();
227 if (section_sp) {
228 if (const auto object_file = section_sp->GetObjectFile())
229 file_name = object_file->GetFileSpec().GetFilename().AsCString();
230 }
231 start_addr = m_base_addr.GetFileAddress();
232 const addr_t end_addr = (start_addr == LLDB_INVALID_ADDRESS)
234 : start_addr + GetByteSize();
235 s->Printf("%s[0x%" PRIx64 "-0x%" PRIx64 ")", file_name, start_addr, end_addr);
236 return true;
237}
238
240 if (!IsValid() || !rhs.IsValid())
241 return false;
242 return m_base_addr == rhs.GetBaseAddress() &&
243 m_byte_size == rhs.GetByteSize();
244}
245
247 return !(*this == rhs);
248}
A section + offset based address range class.
Definition: AddressRange.h:25
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:211
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
Address m_base_addr
The section offset base address of this range.
Definition: AddressRange.h:249
bool operator!=(const AddressRange &rhs)
bool operator==(const AddressRange &rhs)
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.
bool GetDescription(Stream *s, Target *target) const
void Clear()
Clear the object's state.
void DumpDebug(Stream *s) const
Dump a debug description of this object to a Stream.
AddressRange()
Default constructor.
bool Contains(const Address &so_addr) const
Check if a section offset address is contained in this range.
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'...
bool Extend(const AddressRange &rhs_range)
Extends this range with rhs_range if it overlaps this range on the right side.
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:223
lldb::addr_t m_byte_size
The size in bytes of this address range.
Definition: AddressRange.h:250
A section + offset based address class.
Definition: Address.h:62
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:313
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
void Clear()
Clear the object's state.
Definition: Address.h:181
DumpStyle
Dump styles allow the Address::Dump(Stream *,DumpStyle) const function to display Address contents in...
Definition: Address.h:66
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:87
@ DumpStyleSectionNameOffset
Display as the section name + offset.
Definition: Address.h:74
@ DumpStyleInvalid
Invalid dump style.
Definition: Address.h:68
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
Definition: Address.h:93
@ DumpStyleSectionPointerOffset
Display as the section pointer + offset (debug output).
Definition: Address.h:80
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:99
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false, std::optional< Stream::HighlightSettings > settings=std::nullopt) const
Dump a description of this object to a Stream.
Definition: Address.cpp:408
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:293
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:329
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:355
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:691
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:134
size_t PutChar(char ch)
Definition: Stream.cpp:131
const ArchSpec & GetArchitecture() const
Definition: Target.h:1023
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
void DumpAddressRange(llvm::raw_ostream &s, uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address range to this stream.
Definition: Stream.cpp:120
void DumpAddress(llvm::raw_ostream &s, uint64_t addr, uint32_t addr_size, const char *prefix=nullptr, const char *suffix=nullptr)
Output an address value to this stream.
Definition: Stream.cpp:108
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:409
uint64_t addr_t
Definition: lldb-types.h:80
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:368