1 //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/AddressRange.h" 11 #include "lldb/Core/ArchSpec.h" // for ArchSpec 12 #include "lldb/Core/Module.h" 13 #include "lldb/Target/Target.h" 14 #include "lldb/Utility/ConstString.h" // for ConstString 15 #include "lldb/Utility/FileSpec.h" // for FileSpec 16 #include "lldb/Utility/Stream.h" 17 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS 18 19 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH 20 21 #include <memory> // for shared_ptr 22 23 #include <inttypes.h> // for PRIx64 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(), m_byte_size(0) {} 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() {} 46 47 // bool 48 // AddressRange::Contains (const Address &addr) const 49 //{ 50 // const addr_t byte_size = GetByteSize(); 51 // if (byte_size) 52 // return addr.GetSection() == m_base_addr.GetSection() && 53 // (addr.GetOffset() - m_base_addr.GetOffset()) < byte_size; 54 //} 55 // 56 // bool 57 // AddressRange::Contains (const Address *addr) const 58 //{ 59 // if (addr) 60 // return Contains (*addr); 61 // return false; 62 //} 63 64 bool AddressRange::ContainsFileAddress(const Address &addr) const { 65 if (addr.GetSection() == m_base_addr.GetSection()) 66 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 67 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 68 if (file_base_addr == LLDB_INVALID_ADDRESS) 69 return false; 70 71 addr_t file_addr = addr.GetFileAddress(); 72 if (file_addr == LLDB_INVALID_ADDRESS) 73 return false; 74 75 if (file_base_addr <= file_addr) 76 return (file_addr - file_base_addr) < GetByteSize(); 77 78 return false; 79 } 80 81 bool AddressRange::ContainsFileAddress(addr_t file_addr) const { 82 if (file_addr == LLDB_INVALID_ADDRESS) 83 return false; 84 85 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 86 if (file_base_addr == LLDB_INVALID_ADDRESS) 87 return false; 88 89 if (file_base_addr <= file_addr) 90 return (file_addr - file_base_addr) < GetByteSize(); 91 92 return false; 93 } 94 95 bool AddressRange::ContainsLoadAddress(const Address &addr, 96 Target *target) const { 97 if (addr.GetSection() == m_base_addr.GetSection()) 98 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 99 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target); 100 if (load_base_addr == LLDB_INVALID_ADDRESS) 101 return false; 102 103 addr_t load_addr = addr.GetLoadAddress(target); 104 if (load_addr == LLDB_INVALID_ADDRESS) 105 return false; 106 107 if (load_base_addr <= load_addr) 108 return (load_addr - load_base_addr) < GetByteSize(); 109 110 return false; 111 } 112 113 bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const { 114 if (load_addr == LLDB_INVALID_ADDRESS) 115 return false; 116 117 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target); 118 if (load_base_addr == LLDB_INVALID_ADDRESS) 119 return false; 120 121 if (load_base_addr <= load_addr) 122 return (load_addr - load_base_addr) < GetByteSize(); 123 124 return false; 125 } 126 127 void AddressRange::Clear() { 128 m_base_addr.Clear(); 129 m_byte_size = 0; 130 } 131 132 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style, 133 Address::DumpStyle fallback_style) const { 134 addr_t vmaddr = LLDB_INVALID_ADDRESS; 135 int addr_size = sizeof(addr_t); 136 if (target) 137 addr_size = target->GetArchitecture().GetAddressByteSize(); 138 139 bool show_module = false; 140 switch (style) { 141 default: 142 break; 143 case Address::DumpStyleSectionNameOffset: 144 case Address::DumpStyleSectionPointerOffset: 145 s->PutChar('['); 146 m_base_addr.Dump(s, target, style, fallback_style); 147 s->PutChar('-'); 148 s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size); 149 s->PutChar(')'); 150 return true; 151 break; 152 153 case Address::DumpStyleModuleWithFileAddress: 154 show_module = true; 155 LLVM_FALLTHROUGH; 156 case Address::DumpStyleFileAddress: 157 vmaddr = m_base_addr.GetFileAddress(); 158 break; 159 160 case Address::DumpStyleLoadAddress: 161 vmaddr = m_base_addr.GetLoadAddress(target); 162 break; 163 } 164 165 if (vmaddr != LLDB_INVALID_ADDRESS) { 166 if (show_module) { 167 ModuleSP module_sp(GetBaseAddress().GetModule()); 168 if (module_sp) 169 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString( 170 "<Unknown>")); 171 } 172 s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size); 173 return true; 174 } else if (fallback_style != Address::DumpStyleInvalid) { 175 return Dump(s, target, fallback_style, Address::DumpStyleInvalid); 176 } 177 178 return false; 179 } 180 181 void AddressRange::DumpDebug(Stream *s) const { 182 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64 183 ", byte_size = 0x%16.16" PRIx64 "\n", 184 static_cast<const void *>(this), 185 static_cast<void *>(m_base_addr.GetSection().get()), 186 m_base_addr.GetOffset(), GetByteSize()); 187 } 188 // 189 // bool 190 // lldb::operator== (const AddressRange& lhs, const AddressRange& rhs) 191 //{ 192 // if (lhs.GetBaseAddress() == rhs.GetBaseAddress()) 193 // return lhs.GetByteSize() == rhs.GetByteSize(); 194 // return false; 195 //} 196