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
9 #include "lldb/Core/AddressRange.h"
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/Section.h"
12 #include "lldb/Target/Target.h"
13 #include "lldb/Utility/ConstString.h"
14 #include "lldb/Utility/FileSpec.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
25 namespace lldb_private {
26 class SectionList;
27 }
28
29 using namespace lldb;
30 using namespace lldb_private;
31
AddressRange()32 AddressRange::AddressRange() : m_base_addr() {}
33
AddressRange(addr_t file_addr,addr_t byte_size,const SectionList * section_list)34 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
35 const SectionList *section_list)
36 : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
37
AddressRange(const lldb::SectionSP & section,addr_t offset,addr_t byte_size)38 AddressRange::AddressRange(const lldb::SectionSP §ion, addr_t offset,
39 addr_t byte_size)
40 : m_base_addr(section, offset), m_byte_size(byte_size) {}
41
AddressRange(const Address & so_addr,addr_t byte_size)42 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
43 : m_base_addr(so_addr), m_byte_size(byte_size) {}
44
45 AddressRange::~AddressRange() = default;
46
Contains(const Address & addr) const47 bool 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
ContainsFileAddress(const Address & addr) const63 bool AddressRange::ContainsFileAddress(const Address &addr) const {
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
ContainsFileAddress(addr_t file_addr) const80 bool AddressRange::ContainsFileAddress(addr_t file_addr) const {
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
ContainsLoadAddress(const Address & addr,Target * target) const94 bool AddressRange::ContainsLoadAddress(const Address &addr,
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
ContainsLoadAddress(addr_t load_addr,Target * target) const112 bool 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
Extend(const AddressRange & rhs_range)126 bool 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
Clear()144 void AddressRange::Clear() {
145 m_base_addr.Clear();
146 m_byte_size = 0;
147 }
148
IsValid() const149 bool AddressRange::IsValid() const {
150 return m_base_addr.IsValid() && (m_byte_size > 0);
151 }
152
Dump(Stream * s,Target * target,Address::DumpStyle style,Address::DumpStyle fallback_style) const153 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
154 Address::DumpStyle fallback_style) const {
155 addr_t vmaddr = LLDB_INVALID_ADDRESS;
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;
164 case Address::DumpStyleSectionNameOffset:
165 case Address::DumpStyleSectionPointerOffset: {
166 s->PutChar('[');
167 m_base_addr.Dump(s, target, style, fallback_style);
168 s->PutChar('-');
169 addr_t end = m_base_addr.GetOffset() + GetByteSize();
170 if (m_base_addr.GetSection())
171 s->Format("{0}", end);
172 else
173 DumpAddress(s->AsRawOstream(), end, addr_size);
174 s->PutChar(')');
175 return true;
176 }
177
178 case Address::DumpStyleModuleWithFileAddress:
179 show_module = true;
180 [[fallthrough]];
181 case Address::DumpStyleFileAddress:
182 vmaddr = m_base_addr.GetFileAddress();
183 break;
184
185 case Address::DumpStyleLoadAddress:
186 vmaddr = m_base_addr.GetLoadAddress(target);
187 break;
188 }
189
190 if (vmaddr != LLDB_INVALID_ADDRESS) {
191 if (show_module) {
192 ModuleSP module_sp(GetBaseAddress().GetModule());
193 if (module_sp)
194 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
195 "<Unknown>"));
196 }
197 DumpAddressRange(s->AsRawOstream(), vmaddr, vmaddr + GetByteSize(),
198 addr_size);
199 return true;
200 } else if (fallback_style != Address::DumpStyleInvalid) {
201 return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
202 }
203
204 return false;
205 }
206
DumpDebug(Stream * s) const207 void AddressRange::DumpDebug(Stream *s) const {
208 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64
209 ", byte_size = 0x%16.16" PRIx64 "\n",
210 static_cast<const void *>(this),
211 static_cast<void *>(m_base_addr.GetSection().get()),
212 m_base_addr.GetOffset(), GetByteSize());
213 }
214
GetDescription(Stream * s,Target * target) const215 bool AddressRange::GetDescription(Stream *s, Target *target) const {
216 addr_t start_addr = m_base_addr.GetLoadAddress(target);
217 if (start_addr != LLDB_INVALID_ADDRESS) {
218 // We have a valid target and the address was resolved, or we have a base
219 // address with no section. Just print out a raw address range: [<addr>,
220 // <addr>)
221 s->Printf("[0x%" PRIx64 "-0x%" PRIx64 ")", start_addr,
222 start_addr + GetByteSize());
223 return true;
224 }
225
226 // Either no target or the address wasn't resolved, print as
227 // <module>[<file-addr>-<file-addr>)
228 const char *file_name = "";
229 const auto section_sp = m_base_addr.GetSection();
230 if (section_sp) {
231 if (const auto object_file = section_sp->GetObjectFile())
232 file_name = object_file->GetFileSpec().GetFilename().AsCString();
233 }
234 start_addr = m_base_addr.GetFileAddress();
235 const addr_t end_addr = (start_addr == LLDB_INVALID_ADDRESS)
236 ? LLDB_INVALID_ADDRESS
237 : start_addr + GetByteSize();
238 s->Printf("%s[0x%" PRIx64 "-0x%" PRIx64 ")", file_name, start_addr, end_addr);
239 return true;
240 }
241
operator ==(const AddressRange & rhs)242 bool AddressRange::operator==(const AddressRange &rhs) {
243 if (!IsValid() || !rhs.IsValid())
244 return false;
245 return m_base_addr == rhs.GetBaseAddress() &&
246 m_byte_size == rhs.GetByteSize();
247 }
248
operator !=(const AddressRange & rhs)249 bool AddressRange::operator!=(const AddressRange &rhs) {
250 return !(*this == rhs);
251 }
252