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 32 AddressRange::AddressRange() : m_base_addr() {} 33 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 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 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 47 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 63 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 80 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 94 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 112 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 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 144 void AddressRange::Clear() { 145 m_base_addr.Clear(); 146 m_byte_size = 0; 147 } 148 149 bool AddressRange::IsValid() const { 150 return m_base_addr.IsValid() && (m_byte_size > 0); 151 } 152 153 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 DumpAddress(s->AsRawOstream(), m_base_addr.GetOffset() + GetByteSize(), 170 addr_size); 171 s->PutChar(')'); 172 return true; 173 break; 174 175 case Address::DumpStyleModuleWithFileAddress: 176 show_module = true; 177 [[fallthrough]]; 178 case Address::DumpStyleFileAddress: 179 vmaddr = m_base_addr.GetFileAddress(); 180 break; 181 182 case Address::DumpStyleLoadAddress: 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 204 void AddressRange::DumpDebug(Stream *s) const { 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()), 209 m_base_addr.GetOffset(), GetByteSize()); 210 } 211 212 bool AddressRange::GetDescription(Stream *s, Target *target) const { 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) 233 ? 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 239 bool AddressRange::operator==(const AddressRange &rhs) { 240 if (!IsValid() || !rhs.IsValid()) 241 return false; 242 return m_base_addr == rhs.GetBaseAddress() && 243 m_byte_size == rhs.GetByteSize(); 244 } 245 246 bool AddressRange::operator!=(const AddressRange &rhs) { 247 return !(*this == rhs); 248 } 249